Dans certains cas les droits Unix classiques présentent des limitations. Ces limitations ont conduit à la création d'un système de droits beaucoup plus fin : les ACLs.

Les ACLs (Access Control Lists = Listes de Contrôle d'Accès) permettent de gérer les autorisations d'accès à un fichier de façon beaucoup plus fine qu'avec les mécanismes Unix traditionnels.

Note de novembre 2017

Cet article est un peu ancien, actuellement les ACLs sont activés par défaut sur les distribution GNU/Linux les plus courantes. La première partie sur l'installation et la configuration est donc là davantage pour mémoire. Par contre la sauvegarde manuelle des ACLs sur des sytèmes de fichier type FAT garde son actualité, ainsi que la partie sur l'utilisation des ACLs.

Prérequis

Les informations figurant dans ce document tiennent pour acquis que :

• Vous possédez un système GNU/Linux fonctionnel (Debian, mais si vous possédez une autre distribution vous devrez savoir comment installer un paquet avec le système de gestion de paquet de votre distribution).
• Vous savez utiliser les commandes d'administration courantes en ligne de commande.
• Vous savez utiliser un éditeur de texte (vi ou vim, emacs, nano, joe etc.) en ligne de commande.
• Vous disposez d'un accès « root » sur la machine où vous installez les ACLs.

Installation et configuration des ACLs

Vérification du support noyau

Il faut vérifier que les ACLs soient actives dans le noyau (elles le sont souvent par défaut). On recherche cette information dans le fichier de configuration du noyau se trouvant dans le répertoire /boot. Par exemple sur ma Debian dont le noyau est en version 2.6.32, je trouve le fichier /boot/config-2.6.32-5-686. vous devez adapter le nom de ce fichier à votre configuration :

grep ACL /boot/config-2.6.32-5-686

Si jamais ce fichier n'est pas disponible vous pouvez utiliser la commande suivante :

# zgrep POSIX_ACL /proc/config.gz

On doit obtenir quelque chose dans ce genre (il est possible que vous n'ayez pas tous ces Systèmes de fichier d'activés, par exemple vous pourriez avoir CONFIG_NFSD_V3_ACL is not set) :

# CONFIG_SND_MSND_PINNACLE is not set
CONFIG_EXT2_FS_POSIX_ACL=y
CONFIG_EXT3_FS_POSIX_ACL=y
CONFIG_EXT4_FS_POSIX_ACL=y
CONFIG_REISERFS_FS_POSIX_ACL=y
CONFIG_JFS_POSIX_ACL=y
CONFIG_FS_POSIX_ACL=y
CONFIG_XFS_POSIX_ACL=y
CONFIG_OCFS2_FS_POSIX_ACL=y
CONFIG_BTRFS_FS_POSIX_ACL=y
CONFIG_GENERIC_ACL=y
CONFIG_TMPFS_POSIX_ACL=y
CONFIG_JFFS2_FS_POSIX_ACL=y
CONFIG_NFS_V3_ACL=y
CONFIG_NFSD_V2_ACL=y
CONFIG_NFSD_V3_ACL=y
CONFIG_NFS_ACL_SUPPORT=m

Si ces options ont la valeur « y » (yes) le noyau est compilé avec le support pour les ACLs. Si ce n'est pas le cas il n'y a plus qu'à le recompiler avec ces options ACL.

On voit au passage quels systèmes de fichier peuvent supporter les ACLs, ici nous avons les possibilités suivantes : ext2, ext3, ext4, reiserfs, jfs, xfs, btrfs, ocfs, et les versions récentes de NFS, soit un large choix.

Installation des ACLs

Il faut installer le paquet acl. En tant qu'utilisateur root bien entendu :

root@ks.yakati.info:~# aptitude install acl

Montage des partitions avec les ACLs

Montage temporaire

Une fois les ACLs installées il faut remonter les partitions sur lesquelles on veut les appliquer. En imaginant que la partition sur laquelle on souhaite les activer soit sda1

root@ks.yakati.info:~# mount -o remount,acl /dev/sda1

Montage permanent

Pour avoir les ACLs de façon permanente il faut modifier /etc/fstab en ajoutant l'option acl aux options de montage comme ci-dessous :

/dev/sda1   /   ext3    errors=remount-ro       0       1

Remplacé par :

/dev/sda1   /   ext3    acl,errors=remount-ro   0       1

Les ACLs peuvent bien entendu être utilisées sur n'importe quel poste sous Linux (ou Unix), je les trouve particulièrement utiles sur les serveurs pour gérer, par exemple, l'accès d'un utilisateur chargé des sauvegardes sur une arborescence web dans /var/www ou bien des droits complexes dans des répertoires partagés par des équipes dont les membres peuvent avoir des droits différents selon une structure trop complexe pour les droits Unix classiques (voir par exemple http://okki666.free.fr/docmaster/articles/linux100.htm, un peu ancien car depuis les outils de sauvegarde tiennent compte des ACLs et savent les sauvegarder voir le cadre ci-dessou, mais qui expose très bien les fondements de la question).

Sauvegarde manuelle

De nos jours (2013) les outils de copie, déplacement et archivage comme cp, tar, mv, rsync etc. savent prendre en compte les ACLs. Par contre si vous devez sauver des fichiers par exemple sur une clé USB classiquement formatée en fat32, l'antique système de fichier de MSDOS^® qui ne connaît même pas les notions d'utilisateur et de groupe il faudra sauvegarder les ACLs à la main dans un fichier à part et les restaurer une fois que les données seront installées sur un système de fichier connaissant les ACLs :

$ tar czf Documents.tgz Documents/
$ getfacl -R --absolute-names Documents/ > documents.acl

On obtient alors un fichier documents.acl contenant toutes les ACLs du répertoire et de son contenu. Une fois l'archive décompressée sur un disque il suffit de restaurer les ACLs :

$ tar xzf Documents.tgz
$ setfacl --restore=documents.acl

Sur quels répertoires activer les ACLs ?

Si vous avez la main sur le partitionnement de la machine il est intéressant de monter les répertoires où vous voulez utiliser les ACLs sur des partitions différentes. Si votre système est installé dans une grande partition / vous serez obliger d'activer les ACLs pour toute l'arborescence.

On peut se dispenser d'activer les ACLs sur certaines arborescence comme /usr, /etc, /bin, /sbin et tous les répertoires de ce type. En plaçant par exemple /var/www, /var/lib/mysql, /home dans des partition dédiées, on peut n'activer les ACLs que sur ces partitions.

Un exemple de /etc/fstab partitionné pour placer à bon escient les ACLs :

~$ cat /etc/fstab
# <sys.fichiers><pt de montage><type> <options>  <dump> <pass>
/dev/sda2       /              ext3    errors=remount-ro        0       1
/dev/sda1       /boot          ext2    noauto,errors=remount-ro 0       1
/dev/sda3       swap           swap    defaults                 0       0
/dev/sda5       /usr           ext3    defaults                 1       2
/dev/sda6       /var/lib/mysql ext3    acl,defaults             1       2
/dev/sda7       /opt           ext3    acl,defaults             1       2
/dev/sda8       /home          ext3    acl,defaults             1       2
/dev/sda9       /usr/local     ext3    acl,defaults             1       2
proc            /proc          proc    defaults                 0       0
sysfs           /sys           sysfs   defaults                 0       0

Utilisation

Notions de base : mettre et retirer des ACLs sur un fichier

Nous allons prendre une série d'exemples qui seront plus parlants qu'un grand blabla théorique. Commençons par créer un fichier :

marc@ks.yakati.info:~$ touch fichieracl

Pour voir les ACLs sur ce fichier la commande est getfacl.

marc@ks.yakati.info:~$ getfacl fichieracl
# file: fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
other::r--

Placer les ACLs

Pour autoriser la lecture et écriture au groupe users par exemple (je n'ai pas de groupe share sur ma machine) on utilise la commande setfacl :

marc@ks.yakati.info:~$ setfacl -m g:users:rw fichieracl

Cette syntaxe de setfacl signifie :

• -m -> modifier les ACLs d'un fichier
• g -> introduit le nom du groupe
• users -> le nom du groupe
• rw -> les droits de lecture écriture
• : -> séparateur entre les éléments de la commande

On peut définir les ACL's pour le groupe en utilisant comme ici g, mais aussi pour un utilisateur avec u, pour tout le monde avec o. On peut également définir le masque avec m, dont nous verrons un peu plus bas l'usage.

Si l'on regarde ce que sont devenus les droits ACLs :

marc@ks.yakati.info:~$ getfacl fichieracl
# file: fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

tous les membres du groupe users auront accès en lecture écriture à ce fichier.

Quand des ACL's sont montés sur un système de fichier on voit une petite croix après les droits unix dans un ls :

marc@ks.yakati.info:~$ ls -l repacl/
total 12
-rw-rw-r--+ 1 marc marc 0 2008-02-13 12:22 fichieracl
-rw-rw-r--+ 1 marc marc 0 2008-02-13 13:53 fichieracl2
-rw-rw-r--+ 1 marc marc 0 2008-02-13 14:02 fichieracl3

Retirer les ACLs

Pour remettre les ACLs à 0 on utiliserait l'option -b de setfacl :

marc@ks.yakati.info:~$ setfacl -b fichieracl

La notion de « mask »

De même qu'il existe un umask dans les droits classiques Unix il existe également une notion de masque dans les ACL's.

Les droits fixés dans le masque ne pourront être outrepassés lors de la fixation des ACL's. Là encore il est préférable de prendre un exemple. Nous allons détailler la création d'un fichier et la fixation de droits ACL's en tenant compte du masque. Donc nous créons un autre fichier et regardons les droits Unix lors de la création :

marc@ks.yakati.info:~$ touch fichieracl2
marc@ks.yakati.info:~$ ls -l fichieracls2
-rw-r--r-- 1 marc marc 0 déc.  10 13:32 fichieracls2
marc@ks.yakati.info:~$ getfacl fichieracls2
# file: fichieracls2
# owner: marc
# group: marc
user::rw-
group::r--
other::r--

Les droits du fichier sont -rw-r--r--, soit lecture écriture pour le possesseur, lecture seule pour le groupe et le reste du monde, soit des droits en octal 644. Ces droits, souvent choisis par défaut sur la majorité des distributions, sont fixés par le umask défini pour l'utilisateur, qui a ici la valeur 0022. Les droits ACL's en sont le reflet.

Donnons maintenant les droits de lecture et écriture au groupe users :

marc@ks.yakati.info:~$ setfacl -m g:users:rw- fichieracls2 

On peut regarder les droits Unix standards et les ACL's :

marc@ks.yakati.info:~$ ls -l fichieracls2 
-rw-rw-r--+ 1 marc marc 0 déc.  10 13:32 fichieracls2
marc@ks.yakati.info:~$ getfacl fichieracls2 
# file: fichieracls2
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

Deux constatations, d'une part les droits Unix ont été alignés sur les ACL's et d'autre part dans la liste des droits ACL's s'est rajoutée une ligne mask::rw-.

Maintenant fixons un masque pour les ACL's qui soit plus contraignant que les droits ACL's donnés au groupe users, un masque qui ne donne que le droit de lecture alors que le groupe avait droit de lecture et d'écriture :

marc@ks.yakati.info:~$ setfacl -m m::r-- fichieracls2

On constate qu'une nouvelle ligne est apparue ainsi qu'un commentaire dans l'affichage des ACL's :

marc@ks.yakati.info:~$ getfacl fichieracls2
# file: fichieracls2
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rwx         #effective:r--
mask::r--
other::r--

On voit le masque que l'on a explicitement défini (mask::r--) et que les droits du groupe n'ont pas été modifiés mais sont simplement limités par le masque, ce qu'indique le commentaire #effective:r-- donnant les droits effectifs.

Imaginons que le fichier ait des droits ACL's en lecture écriture pour les groupes users et mysql et un droit de lecture écriture exécution à l'utilisateur www-data. Ses droits ACL's ressembleraient à ça :

marc@ks.yakati.info:~$ setfacl -m u:www-data:rwx fichieracls2
marc@ks.yakati.info:~$ setfacl -m g:users:rw- fichieracls2
marc@ks.yakati.info:~$ setfacl -m g:mysql:rw- fichieracls2
marc@ks.yakati.info:~$ getfacl fichieracls2
# file: fichieracls2
# owner: marc
# group: marc
user::rw-
user:www-data:rwx
group::r--
group:users:rw-
group:mysql:rw-
mask::rwx
other::r--

Si l'on veut d'un coup ne laisser à ces groupes et utilisateurs que le droit de lecture il suffit de faire :

marc@ks.yakati.info:~$ setfacl -m m::r-- fichieracls2

Et l'on obtient le résultat :

marc@ks.yakati.info:~$ getfacl fichieracls2
# file: fichieracls2
# owner: marc
# group: marc
user::rw-
user:www-data:rwx       #effective:r--
group::r--
group:users:rw-         #effective:r--
group:mysql:rw-         #effective:r--
mask::r--
other::r--

Le masque permet ainsi de changer d'un coup les droits pour une multiplicité d'utilisateurs et groupes.

Mettre des droits récursifs sur une arborescence

-R aloue les ACLs récursivement dans le répertoire et ses sous-répertoires. Créons un répertoire :

marc@ks.yakati.info:~$ mkdir repacl

plaçons-y notre fichier :

marc@ks.yakati.info:~$ mv fichieracl repacl/

On voit maintenant que les droits du répertoire sont :

marc@ks.yakati.info:~$ getfacl repacl/
# file: repacl
# owner: marc
# group: marc
user::rwx
group::r-x
other::r-x

et ceux du fichier

marc@ks.yakati.info:~$ getfacl repacl/fichieracl
# file: repacl/fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

Réinitialisons les ACLs du fichier :

marc@ks.yakati.info:~$ setfacl -b repacl/fichieracl
On constate que ça a marché :
marc@ks.yakati.info:~$ getfacl repacl/fichieracl
# file: repacl/fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
other::r--

Créons maintenant un autre fichier :

marc@ks.yakati.info:~$ touch repacl/fichieracl2

On contrôle :

marc@ks.yakati.info:~$ getfacl -R repacl/
# file: repacl
# owner: marc
# group: marc
user::rwx
group::r-x
other::r-x

# file: repacl/fichieracl2
# owner: marc
# group: marc
user::rw-
group::r--
other::r--

# file: repacl/fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
other::r--

Les droits sont les droits par défaut sur le répertoir et les deux fichiers qu'il contient Appliquons maintenant des ACLs de manière récursive sur le répertoire (qui toucheront donc aussi son contenu).

marc@ks.yakati.info:~$ setfacl -R -m g:users:rw repacl/

On contrôle :

marc@ks.yakati.info:~$ getfacl -R repacl/
# file: repacl
# owner: marc
# group: marc
user::rwx
group::r-x
group:users:rw-
mask::rwx
other::r-x

# file: repacl/fichieracl2
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

# file: repacl/fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

L'option -R fonctionne également sur la commande getfacl.

On voit que tout le monde a les bons droits.

Faire hériter des fichiers des ACLs du répertoire

Si l'on veut que tout nouveau fichier créé dans repacl hérite des ACLs du répertoire père on a besoin de l'option d :

marc@ks.yakati.info:~$ setfacl -R -m d:g:users:rw repacl/

ce qui donne :

marc@ks.yakati.info:~$ getfacl -R repacl/
# file: repacl
# owner: marc
# group: marc
user::rwx
group::r-x
group:users:rw-
mask::rwx
other::r-x
default:user::rwx
default:group::r-x
default:group:users:rw-
default:mask::rwx
default:other::r-x

# file: repacl/fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

# file: repacl/fichieracl2
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

Le répertoire a maintenant un groupe ACL par défaut. Créons un nouveau fichier dans le répertoire :

marc@ks.yakati.info:~$ touch repacl/fichieracl3

On vérifie :

marc@ks.yakati.info:~$ getfacl -R repacl/
# file: repacl
# owner: marc
# group: marc
user::rwx
group::r-x
group:users:rw-
mask::rwx
other::r-x
default:user::rwx
default:group::r-x
default:group:users:rw-
default:mask::rwx
default:other::r-x

# file: repacl/fichieracl3
# owner: marc
# group: marc
user::rw-
group::r-x                      #effective:r--
group:users:rw-
mask::rw-
other::r--

# file: repacl/fichieracl
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

# file: repacl/fichieracl2
# owner: marc
# group: marc
user::rw-
group::r--
group:users:rw-
mask::rw-
other::r--

Le fichier fichieracl3 a bien hérité de group:users:rw-, mais on voit apparaître un commentaire dont on vu qu'il était lié au mask des ACL's : group::r-x #effective:r--

Les permissions de type permissions de groupe incluent les droit d'écriture. Classiquement un tel bit de permission devrait indiquer l'accès en écriture du groupe possesseur. Avec les ACLs, les permissions réelles sont définies par l'intersection des permissions du groupe possesseur et du masque d'entrée. Les permissions réelles pour le groupe possesseur dans cet exemple sont toujours r-x, les mêmes permissions qui existaient avant la création des nouvelles entrées ACL's avec setfacl.

Les permissions de groupe peuvent être modifiées en utilisant setfacl ou chmod. Si il n'existe pas d'entrée de masque, chmod modifie les permissions du groupe possesseur comme il le ferait traditionnellement sans ACL's. L'exemple suivant retire l'accès en écriture sur un fichier ayant un accès pour l'utilisateur www-data au groupe pour voir ce que ça va donner.

marc@ks.yakati.info:~$ chmod g-w repacl/
marc@ks.yakati.info:~$ getfacl repacl/
# file: repacl/
# owner: marc
# group: marc
user::rwx
user:www-data:rwx       #effective:r-x
group::r-x
mask::r-x
other::r-x

Comme on voit, si une définition de droits ACL's contient des permissions qui sont désactivées par le masque d'entrée, getfacl ajoute un commentaire montrant le jeu de permissions effectives accordées. Si le groupe possesseur avait eu un accès en écriture, il y aurait eu un commentaire similaire pour cette définition. Voyons ce qui se passe si l'on redonne le droit d'écriture au groupe de nouveau.

marc@ks.yakati.info:~$ chmod g+w repacl/
marc@ks.yakati.info:~$ getfacl repacl/
# file: repacl/
# owner: marc
# group: marc
user::rwx
user:www-data:rwx
group::r-x
mask::rwx
other::r-x

Après avoir ajouté le droit d'écriture au groupe, les ACL's définissent les mêmes droits qu'avant d'avoir enlevé la permission. La commande chmod ne détruit pas les permissions d'accès, cette préservation des droits est une des fonctionnalités importantes des ACLs POSIX.

Cas pratique d'utilisation

Je sauvegarde mes serveurs distants avec rsbackup, un utilitaire qui utilise rsync pour réaliser des sauvegardes incrémentales. Pour pouvoir l'utiliser il faut sur le serveur distant un utilisateur accessible par ssh ayant des droits de lecture sur tous les éléments que l'on veut sauvegarder.

Les ACLs Posix permettent de donner à un utilisateur rbackup le droit de lecture seule sur des répertoires entiers sans avoir à jongler avec les groupes, SGID et autres, car les droits unix ont souvent le défaut de conduire à des permissions trop larges ou trop étroites.

Sur Debian les sites web sont par défaut dans un répertoire /var/www il suffit donc de donner des droits de lecture à rbackup sur toute cette arborescence :

setfacl -R -m d:m::rwx /var/www/
setfacl -R -x d:u:rbackup:r-x /var/www/
setfacl -R -m u:rbackup:r-x /var/www/

L'utilisateur rbackup peut alors rentrer dans tous les répertoire sous /var/www et lire et copier l'ensemble des fichiers et répertoires y figurant.

Quelques ressources concernant les ACLs :

Au format pdf

Quelques papiers de spécialistes, dont Andreas Grünbacher de la société SuSE qui est un des créateurs et promoteur des ACLs pour GNU/Linux.

Un document en français, très pédagogique, au format pdf écrit par Lionel Tricon en 2006 et disponible au format pdf ici en téléchargement.

Une ressource fondamentale abondamment utilisée ici est le papier (en anglais) d'Andreas Grünbacher (de la société SuSE) qui est disponibles (également au format pdf) ici en téléchargement.

Une autre ressource est un extrait du symposium Linux de 2010, auquel participait Andreas Grünbacher, également en pdf et disponible ici en téléchargement.

Sur le site de l'idris

• Ergon : File access management, ACL
• How to configure the access rights to your data
• The idracl command

Ailleurs sur le web

• Gestion des droits de fichier sur developpez.com