Configuration et affichage d'ACL dans des fichiers ZFS en format compact

Vous pouvez définir et afficher les droits relatifs aux fichiers ZFS en format compact utilisant 14 lettres uniques pour représenter les droits. Les lettres représentant les permissions compactes sont répertoriées dans le Tableau 8–2 et le Tableau 8–3.

Vous pouvez afficher les listes d'ACL compactes pour les fichiers et les répertoires à l'aide de la commande ls -V. Exemple :

# ls -V file.1
-rw-r--r--   1 root     root      206663 Jun 17 10:07 file.1
            owner@:--x-----------:------:deny
            owner@:rw-p---A-W-Co-:------:allow
            group@:-wxp----------:------:deny
            group@:r-------------:------:allow
         everyone@:-wxp---A-W-Co-:------:deny
         everyone@:r-----a-R-c--s:------:allow

Cette sortie d'ACL compacte est décrite comme suit :

owner@

Les permissions d'exécution sur le fichier est refusée au propriétaire (x= execute).

owner@

Le propriétaire peut lire ou modifier le contenu du fichier (rw=read_data/write_data, p=append_data). Il peut également modifier les attributs du fichier, tels que les horodatages, les attributs étendus et les ACL (A=write_xattr , W=write_attributes et C=write_acl). De plus, le propriétaire peut modifier la propriété du fichier (o=write_owner).

group@

Les droits de modification et d'exécution sur le fichier sont refusés au groupe (write_data, p=append_data et x=execute).

group@

Les permissions de lecture sur le fichier sont accordées au groupe (r= read_data).

everyone@

Les permissions d'exécution ou de modification du contenu du fichier, ou de modification de tout attribut du fichier sont refusés à toute personne n'étant ni son propriétaire ni membre du groupe propriétaire du (w= write_data, x=execute, p =append_data, A=write_xattr , W=write_attributes, C= write_acl et o=write_owner).

everyone@

Toute personne n'étant pas le propriétaire du fichier ou membre du groupe propriétaire du fichier ne peut ni lire, ni synchroniser le fichier et ses attributs (r= read_data, a=append_data, R=read_xattr, c=read_acl et s=synchronize). Le droit d'accès synchronize n'est actuellement pas implémenté.

Le format d'ACL compact dispose deses avantages suivants par rapport au format détaillé :

• Les droits peuvent être spécifiés en tant qu'arguments de position pour la commande chmod.

• Les traits d'union (-) permettant d'identifier l'absence de permission peuvent être supprimés. Seules les lettres nécessaires doivent être spécifiées.

• Les indicateurs de droits et d'héritage sont configurés de la même manière.

Pour obtenir des informations sur l'utilisation du format d'ACL détaillé, consultez Configuration et affichage d'ACL dans des fichiers ZFS en format détaillé.

Exemple 8–10 Configuration et affichage des ACL en format compact

Dans l'exemple suivant, une ACL triviale existe dans le fichier file.1 :

# ls -V file.1
-rw-r--r--   1 root     root      206663 Jun 17 10:07 file.1
            owner@:--x-----------:------:deny
            owner@:rw-p---A-W-Co-:------:allow
            group@:-wxp----------:------:deny
            group@:r-------------:------:allow
         everyone@:-wxp---A-W-Co-:------:deny
         everyone@:r-----a-R-c--s:------:allow

Dans l'exemple suivant, les permissions read_data/execute sont ajoutées à l'utilisateur gozer dans le fichier .

# chmod A+user:gozer:rx:allow file.1
# ls -V file.1
-rw-r--r--+  1 root     root      206663 Jun 17 10:07 file.1
        user:gozer:r-x-----------:------:allow
            owner@:--x-----------:------:deny
            owner@:rw-p---A-W-Co-:------:allow
            group@:-wxp----------:------:deny
            group@:r-------------:------:allow
         everyone@:-wxp---A-W-Co-:------:deny
         everyone@:r-----a-R-c--s:------:allow

Une autre méthode d'ajout des mêmes permissions pour l'utilisateur gozer consiste à insérer une entrée d'ACL à un emplacement spécifique, par exemple 4. Ainsi, les ACL existantes aux emplacements 4–6 sont déplacées vers le bas. Exemple :

# chmod A4+user:gozer:rx:allow file.1
# ls -V file.1
-rw-r--r--+  1 root     root      206663 Jun 17 10:16 file.1
            owner@:--x-----------:------:deny
            owner@:rw-p---A-W-Co-:------:allow
            group@:-wxp----------:------:deny
            group@:r-------------:------:allow
        user:gozer:r-x-----------:------:allow
         everyone@:-wxp---A-W-Co-:------:deny
         everyone@:r-----a-R-c--s:------:allow

Dans l'exemple suivant, l'utilisateur gozer se voit accorder les droits de lecture, d'écriture et d'exécution hérités des fichiers et répertoires récemment créés.

# chmod A+user:gozer:rwx:fd:allow dir.2
# ls -dV dir.2
drwxr-xr-x+  2 root     root           2 Jun 17 10:19 dir.2
        user:gozer:rwx-----------:fd----:allow
            owner@:--------------:------:deny
            owner@:rwxp---A-W-Co-:------:allow
            group@:-w-p----------:------:deny
            group@:r-x-----------:------:allow
         everyone@:-w-p---A-W-Co-:------:deny
         everyone@:r-x---a-R-c--s:------:allow

Vous pouvez également couper et coller les droits et les indicateurs d'héritage à partir de la sortie ls -V en format chmod compact. Par exemple, pour dupliquer les permissions et les indicateurs d'héritage du répertoire dir.2 de l'utilisateur gozer vers le répertoire dir.2 de l'utilisateur cindys , copiez et collez les permissions et les indicateurs d'héritage (rwx-----------:fd----:allow) dans la commande chmod comme suit :

# chmod A+user:cindys:rwx-----------:fd----:allow dir.2
# ls -dV dir.2
drwxr-xr-x+  2 root     root           2 Jun 17 10:19 dir.2
       user:cindys:rwx-----------:fd----:allow
        user:gozer:rwx-----------:fd----:allow
            owner@:--------------:------:deny
            owner@:rwxp---A-W-Co-:------:allow
            group@:-w-p----------:------:deny
            group@:r-x-----------:------:allow
         everyone@:-w-p---A-W-Co-:------:deny
         everyone@:r-x---a-R-c--s:------:allow

Exemple 8–11 Héritage d'ACL avec la propriété aclinherit définie sur passthrough

Un système de fichiers dont la propriété aclinherit est définie sur passthrough hérite de toutes les entrées d'ACL pouvant être héritées, sans qu'aucune modification ne leur soit apportée. Lorsque cette propriété est définie sur passthrough, les fichiers sont créés avec des permissions déterminées par les ACE pouvant être héritées. Si aucune ACE pouvant être héritée n'affecte les permissions, celles-ci sont alors définies en fonction des permissions demandées à partir de l'application.

Les exemples suivants utilisent la syntaxe ACL compacte pour illustrer le processus d'héritage des permissions en définissant la propriété aclinherit sur passthrough .

Dans cet exemple, une ACL est définie sur le répertoire test1.dir pour forcer l'héritage. La syntaxe crée une entrée d'ACL owner@, group@ et everyone@ pour les fichiers nouvellement créés. Les répertoires nouvellement créés héritent d'une entrée d'ACL @owner, group@ et everyone@. En outre, les répertoires héritent de 6 autres ACE qui appliquent les ACE aux fichiers et répertoires nouvellement créés.

# zfs set aclinherit=passthrough tank/cindys
# pwd
/tank/cindys
# mkdir test1.dir

# chmod A=owner@:rwxpcCosRrWaAdD:fd:allow,group@:rwxp:fd:allow,everyone@::fd:allow 
test1.dir
# ls -Vd test1.dir
drwxrwx---+  2 root     root           2 Jun 17 10:37 test1.dir
            owner@:rwxpdDaARWcCos:fd----:allow
            group@:rwxp----------:fd----:allow
         everyone@:--------------:fd----:allow

Dans cet exemple, un fichier nouvellement créé hérite de l'ACL dont les fichiers nouvellement créés doivent hériter d'après ce qui a été spécifié.

# cd test1.dir
# touch file.1
# ls -V file.1
-rwxrwx---+  1 root     root           0 Jun 17 10:38 file.1
            owner@:rwxpdDaARWcCos:------:allow
            group@:rwxp----------:------:allow
         everyone@:--------------:------:allow

Dans cet exemple, un répertoire nouvellement créé hérite à la fois des ACE contrôlant l'accès à ce répertoire et des ACE à appliquer ultérieurement aux enfants de ce répertoire.

# mkdir subdir.1
# ls -dV subdir.1
drwxrwx---+  2 root     root           2 Jun 17 10:39 subdir.1
            owner@:rwxpdDaARWcCos:fdi---:allow
            owner@:rwxpdDaARWcCos:------:allow
            group@:rwxp----------:fdi---:allow
            group@:rwxp----------:------:allow
         everyone@:--------------:fdi---:allow
         everyone@:--------------:------:allow

Les entrées -di-- et f-i--- permettent d'appliquer l'héritage et ne sont pas prises en compte lors du contrôle d'accès. Dans cet exemple, un fichier est créé avec une ACL insignifiante dans un autre répertoire ne contenant pas d'ACE héritées.

# cd /tank/cindys
# mkdir test2.dir
# cd test2.dir
# touch file.2
# ls -V file.2
-rw-r--r--   1 root     root           0 Jun 17 10:40 file.2
            owner@:--x-----------:------:deny
            owner@:rw-p---A-W-Co-:------:allow
            group@:-wxp----------:------:deny
            group@:r-------------:------:allow
         everyone@:-wxp---A-W-Co-:------:deny
         everyone@:r-----a-R-c--s:------:allow

Exemple 8–12 Héritage d'ACL avec la propriété aclinherit définie sur passthrough-x

Lorsque la propriété aclinherit est définie sur passthrough-x , les fichiers sont créés avec la permission d'exécution (x) pour owner@, group@ ou everyone@, mais seulement si la permission d'exécution est définie dans le mode de création de fichier et dans une ACE héritable affectant ce mode.

L'exemple suivant explique comment hériter de la permission d'exécution en définissant la propriété aclinherit sur passthrough-x.

# zfs set aclinherit=passthrough-x tank/cindys

L'ACL suivante est définie sur /tank/cindys/test1.dir pour permettre l'héritages des ACL exécutables pour les fichiers de owner@, group@ et everyone@.

# chmod A=owner@:rwxpcCosRrWaAdD:fd:allow,group@:rwxp:fd:allow,everyone@::fd:allow test1.dir
# ls -Vd test1.dir
drwxrwx---+  2 root     root           2 Jun 17 10:41 test1.dir
            owner@:rwxpdDaARWcCos:fd----:allow
            group@:rwxp----------:fd----:allow
         everyone@:--------------:fd----:allow

Un fichier (file1) est créé avec les autorisations demandées 0666. Les autorisations obtenues sont 0660. L'autorisation d'exécution n'était pas héritée car le mode de création ne le requérait pas.

# touch test1.dir/file1
# ls -V test1.dir/file1
-rw-rw----+  1 root     root           0 Jun 17 10:42 test1.dir/file1
            owner@:rw-pdDaARWcCos:------:allow
            group@:rw-p----------:------:allow
         everyone@:--------------:------:allow

Ensuite, un fichier exécutable appelé t est généré à l'aide du compilateur cc dans le répertoire testdir.

# cc -o t t.c
# ls -V t
-rwxrwx---+  1 root     root        7396 Jun 17 10:50 t
                 owner@:rwxpdDaARWcCos:------:allow
                 group@:rwxp----------:------:allow
              everyone@:--------------:------:allow

Les autorisations obtenues sont 0770 car cc a demandé des autorisations 0777, ce qui a entraîné l'héritage de l'autorisation d'exécution à partir des entrées propriétaire@, groupe@ et tous les utilisateurs@.