Trucs / astuces & tests sur les ACLs

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Bonjour,

Ayant récemment installé Truenas 13, alors que j'étais sur Freenas 9.3, je me suis retrouvé confronté à une arlésienne (du niveau de Keyser Söze : tout le monde en a entendu parlé, mais personne ne l’a jamais vu) : les ACLs
Ah ces fameux ACLs, c’est un sacré morceau. Il y a des dizaines de posts sur le forum de Truenas et pas vraiment de documentation qui explique les options, le paramétrage...
Vu que j’en ai besoin, j’ai effectué beaucoup de tests, lu beaucoup d’articles, de posts sur les forums. Je vais essayer d’expliquer dans cet article ce que j’ai compris, et de compiler des informations qui m’ont parues importantes et ainsi partager ma maigre expérience.

Tout ce que je vais écrire n’est que mon interprétation. Je suis totalement novice en la matière, donc certains éléments ne seront peut-être pas tout à fait la réalité.

Dans mon cas, il s’agit d’une installation domestique, donc assez simple.
Voici la configuration :
  • 5 datasets :
    • jean
    • marie
    • gabin
    • parents
    • media
  • 3 utilisateurs :
    • jean
    • marie
    • gabin
  • 4 groupes :
    • jean
    • marie
    • gabin
    • parents (jean & marie)

Une des première question à se poser, quel type d’OS vont se connecter aux partages.
En ce qui me concerne, il y aura un PC Windows, un PC Linux, et des ordiphones Android. C’est tout naturel que je choisisse le protocole SMB.

A ce stade, il est important d’avoir à l’esprit que le choix du « type de partage » va influencer la création des datasets.
Lorsqu’on créé un dataset, dans Stockage > Volumes > Ajouter un dataset > Options avancées > Autres options > le paramètre « Type de partage » va directement influencer les paramètres :
  • « Sensibilité à la casse » ;
  • « Mode ACL ».

En effet, « Type de partage » offre deux possibilités :
  • « Generic » :
    • « Sensibilité à la casse » : choix entre « Sensitive » ou « Insensitive » ou « Mixed »
    • « Mode ACL »: choix entre « Passthrough » ou « Restricted »
  • « SMB » :
    • « Sensibilité à la casse » : « Insensitive »
    • « Mode ACL » : « Restricted »




Aparté sur la notion de « sensibilité à la casse » :
  • GNU/Linux & BSD sont des systèmes dits « sensible à la casse » car une distinction est faite entre une lettre écrite en majuscule et la même lettre écrite en minuscule. Par exemple : toto ≠ Toto ≠ toTO.
  • Windows est un système dit « insensible à la casse » car il ne fait pas la distinction entre une lettre écrite en majuscule d’une lettre écrite minuscule. Par exemple : Toto = TOTO = totO = Toto
De ce fait, lorsqu’un partage est destiné servir des postes clients qui fonctionnent sur Windows et Linux, il est préférable de choisir une sensibilité à la casse qui coïncide avec le système le plus restrictif, à savoir Windows.





Il s’avère par ailleurs que le paramètre « Sensibilité à la casse » est irrévocable. Une fois le dataset créé, il ne sera pas possible de modifier ce choix. La seule solution sera de créer un nouveau dataset avec le bon paramètre, copier les données et supprimer le datatset initial.

Ce post (https://askubuntu.com/questions/137...-to-be-settable-post-creation-but-its-read-on) donne des informations sur quelques une des raisons pour lesquelles il n’est pas possible de modifier le choix de la sensibilité à la casse après la création du dataset. En autre, pour des raisons de risque de conflits de fichiers dans la cas où un dataset paramétré comme « sensible à la casse » serait soudainement défini avec un paramétrage « insensible à la casse ». Dans un tel cas, comment le système traiterait les fichiers d’un répertoire portant les noms suivants « Toto » et « tOtO ?

Par ailleurs, dans ce même post on apprend également qu'à l'heure où j'écris ces lignes (novembre 2022), la sensibilité à la casse de type « Mixed » est seulement pris en charge sur les serveurs SMB (https://manpages.ubuntu.com/manpages/focal/en/man8/zfs.8.html).

Donc par déduction, il semble que ce mode puisse poser le même genre de problème (conflits de fichiers) dans le cas d’un accès multi-protocoles aux datasets.

Tout cela pour dire que même si on choisit le mode « Generic », il est sans doute préférable de choisir une sensibilité à la casse de type « Insensitive » (à moins de vraiment savoir ce qu’on fait).


Nous avons donc vu que porter son choix sur le type de partage « SMB » contraint les paramètres « Sensibilité à la casse » et « Mode ACL ».

Ce choix provoque également la création d’une liste d’ACL par défaut disponible dans Stockage > Volumes > cliquer « actions » du dataset souhaité (3 points en bout de ligne) > Modifier les autorisations :
utilisateur propriétaire: root
groupe propriétaire: wheel
owner@: autoriser – full control – hériter
group@: autoriser – full control – hériter
everyone@: autoriser – traverser – non-hériter
group : builtin_users: autoriser – modification – hériter

Je ne sais pas si ce choix provoque d’autres paramétrages non-visibles directement dans l’interface web.


Quelques commandes utiles
  • permettre de voir la liste de toutes les propriétés et les valeurs possibles associées :
zfs list -o
  • renvoyer la valeur définie sur le champ « ACL mode » du dataset :
zfs list -o aclmode </mnt/chemin_du_datatset>
  • renvoyer la valeur définie sur le champ « sensibilité à la case » du dataset :
zfs list -o casesensitivity </mnt/chemin_du_datatset>
  • renvoyer toutes les valeurs définies sur toutes les propriétés d’un dataset :
zfs get all </mnt/<chemin_du_dataset>
  • mettre la propriété « aclmode » sur la valeur « restrited » :
zfs set aclmode=restrited </mnt/<chemin_du_dataset>



Dernière valeur que je n’ai pas évoqué : aclmode=passthrought
C’est cette valeur qui m’a le plus donné de fil à retordre.

Quelques informations sur cette page (https://serverfault.com/questions/858421/what-is-the-difference-between-aclinherit-and-aclmode).
Personnellement, je ne comprends pas du tout la différence entre aclmode=restricted et aclmode=passthrough.

Tout ce que je peux vous dire c’est vous faire part d’un retour d’expérience sur mes tests.
Comme au début de mes tests, je savais que j’accéderai à mes partages via plusieurs plateformes (Windows / Linux), j’avais donc choisi « Generic » comme type de partage et j’avais laissé les valeurs par défaut, à savoir :
  • Mode ACL : passthrouth
  • Sensibilité à la casse : sensitive



Quelques règles sur les ACLs

1] Contrairement aux permissions UNIX qui sont binaires (autorisation ou non), il est possible de configurer une entrée ACL, soit définies sur :
  • « autoriser » ;
  • « non-défini » ;
  • « refuser »
Par exemple :
  • owner@ : rwxp--aARWcCos :-------:allow
  • groupe:ami : rwxpDdaARWc--s :-------:deny

Les permissions définies sur « refuser » sont semble-t-il prioritaires sur les permissions définies sur « autoriser ».
Les permissions « non-définie » symbolisées par « - » sont en faite des autorisations implicites de « refus ».
La grande question, à laquelle je n’ai pas trouvé de réponse : est-ce qu’une autorisation « non-définie » équivaut-elle à une autorisation explicitement définie sur « refuser ».

Un droit est composée de la façon suivante :
owner@ : rwxpDdaARWcCos:dfin-SFI:allow
Pour info, voici la signification des différentes autorisations disponibles avec les ACLs :
  • « r » : lire les données contenu dans un fichier ou affiche le contenu d'un répertoire.
  • « w » : écrire des données, créer de nouveaux fichiers ou modifier toute partie d'un fichier.
  • « x » : exécuter un fichier, se déplacer dans un répertoire ou y effectuer une recherche
  • « p » : ajouter des données à la fin d'un fichier.
  • « D » : supprimer les enfants. Supprimer des fichiers ou des sous-répertoires à l'intérieur d'un répertoire.
  • « d » : supprimer un fichier ou un répertoire.
  • « a » : visualiser les attributs non-ACL d'un fichier ou d'un répertoire.
  • « A » : modifier les attributs non-ACL d'un fichier ou d'un répertoire.
  • « R » : lire les attributs d’un répertoire
  • « W » : modifier les attributs d’un répertoire. Doit avoir l’autorisation de lire les attributs.
  • « c » : visualiser l'ACL
  • « C » : changer l'ACL et le mode de l'ACL.
  • « o » : changer l'utilisateur et le groupe propriétaire du fichier ou du répertoire.
  • « s » : lecture/écriture synchrone de fichiers avec le serveur. Cette permission ne s'applique pas aux clients FreeBSD.

  • « f » : les fichiers héritent de l'ACL du répertoire parent
  • « d » : les sous-répertoires héritent de la liste de contrôle d'accès du répertoire parent
  • « i » : Hérite de la liste de contrôle d'accès du répertoire parent mais ne s'applique qu'aux fichiers ou sous-répertoires nouvellement créés et non au répertoire lui-même
  • « n » : Hérite uniquement de l'ACL du répertoire parent au contenu de premier niveau du répertoire, et non au contenu de second niveau ou suivant
  • « - » : ???Aucune autorisation accordée ???
  • « S » : Indique si un enregistrement d'alarme ou d'audit doit être déclenché en cas d'accès réussi.
  • « F » : Indique si une alarme ou un enregistrement d'audit doit être déclenché lorsqu'un accès échoue.
  • « I » : Indique qu'un ACE a un héritage défini

Sources :
https://www.truenas.com/docs/core/coretutorials/storage/pools/permissions/
https://svennd.be/blog/2022-03-29-truenas-acl/
https://docs.oracle.com/cd/E19120-01/open.solaris/817-2271/6mhupg6p1/index.html#gbbht
https://docs.oracle.com/cd/E19120-01/open.solaris/817-2271/6mhupg6p4/index.html#gbbhx


Truenas propose 4 type d'autorisations prédéfinies (type "base") :
  • Lecture : r-x---a-R-c---
  • Modification : rwxpDdaARWc--s
  • Traverser : --x---a-R-c---
  • Contrôle total : rwxpDdaARWcCos

2] « owner@ », « group@ » et « everyone@ » :
  • « owner@ » semble être l’équivalent de « user » sur les droits unix ; donc le propriétaire d’un dataset
  • « group@ » semble être l’équivalent de « group » sur les droits unix ; donc le groupe propriétaire d’un dataset
  • « evenyone@ » n’a pas vraiment d’équivalent. Il peut s’apparenter à « others » sur les droits unix, mais il semble être plus large car lorsqu’il est défini, il semble également englober l’utilisateur propriétaire et le groupe propriétaire.
Je reviendrais dessus plus tard (Voir le test n°7)

Sources :
https://www.truenas.com/community/threads/file-rights-acl-please-kill-me-now.91439/post-633456
https://www.truenas.com/community/threads/11-3-acl-management-explain-root-wheel-owner-group.81801/
https://docs.oracle.com/cd/E19120-01/open.solaris/817-2271/gbchf/index.html


3] Vous pouvez vous apercevoir que tous les nouveaux utilisateurs sont automatiquement ajoutés au groupe « builtin_user ».
A ce sujet, inutile de créer des groupes « invités » ou « administrateurs », Truenas dispose maintenant de ces groupes génériques :
  • builtin_users : groupe utilisateur qui regroupe tous les utilisateurs créés via l’interface web
  • builtin_administrators : groupe administrateur
  • builtin_guests : groupe invité
Source : https://www.jjworld.fr/installer-freenas-truenas/


4] Notions :
  • ACL du partage
  • ACL du système de fichier
Disponible dans Partages > Partages Windows (SMB) > sélectionner une ligne d’un partage existant > cliquer sur les 3 points verticaux > Modifier l’ACL du Partages.
Lorsqu’on créé un partage SMB, par défaut, une « ACL de partage » de type [contrôle totale - autoriser- Everyone] est créée.

Sur cette page (https://www.truenas.com/community/t...e-between-smb-acls-and-filesystem-acls.90046/)
@anodos donne beaucoup d’information :
  • Par exemple, il conseille de travailler avec l’ACL du système de fichier plutôt que d’utiliser l’ACL du partage.
  • Il explique qu’on peut considérer les ACLs du partage comme les autorisations maximales possibles pour les groupes / utilisateurs.
    (exemple : si l’ACL du partage est configuré en lecture seule pour tout le monde, alors quel que soient les autorisations définies sur les ACLs du système de fichier, tout le monde sera limité en lecture.)
Au delà de cela, en ce qui me concerne, je n’ai pas compris ce qu’étaient les ACLs de partage et la différence avec les ACLs du système de fichier. Si quelqu’un se sent d’expliquer avec des mots simples et dans quel cas utiliser les ACLs de partage, je lui en serais très reconnaissant.

A priori d’après ce même post, il est préférable de laisser « l’ACL de partage » définie par défaut par Truenas au moment de la création du partage SMB (donc : full control – allowed – Everyone).




Sécurité SMB

On trouve sur cette page de la documentation Truenas quelques conseils de sécurité (https://www.truenas.com/docs/solutions/optimizations/security/#smb) :
  • ne pas utiliser SMB 1
  • activer la signature du serveur :
Pour cela, se rendre dans Services > SMB > cliquer sur « Configurer » (crayon) > cliquer sur le bouton « Options avancées » > Paragraphe « Autres options » > Champs « Paramètres auxiliaires » > ajouter : « server signing = mandatory » > cliquer sur le bouton « Enregistrer » > redémarrer le service SMB.
Ayant posé la question sur le forum international (https://www.truenas.com/community/threads/smb-security-server-signing.106132/), il s'avère que la page de la documentation Truenas (donnée ci-dessus) n'est pas tout à fait à jour ou mal rédigé.
A priori, la signature est déjà intégré dans les protocoles SMB 2 et 3. Ce paramètre est donc inutile ici.
  • ne pas activer l'authentification « NTLMv1 Auth » :
Lorsqu'il est défini le service tente d'authentifier les utilisateurs avec le chiffrement NTLMv1 non sécurisé et vulnérable. Ce paramètre permet une rétrocompatibilité avec les anciennes versions de Windows, mais n'est pas recommandé et ne doit pas être utilisé sur des réseaux non fiables.
Cette option se trouve dans Services > SMB > cliquer sur « Configurer » (crayon) > paragraphe « NetBIOS » > case « NTLMv1 Auth »
  • Paramétrage par défaut du partage recommandé :
Disponible dans Partages > Partages Windows (SMB) > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Modifier > Paragraphe « Basique » > Champs « Objectif » > Sélectionner « Default Share Parameters »
Comme on peut le voir sur la capture d'image ci-dessous, ce paramètrage a activé certaines options et en a désactivé d'autres. De plus dans ce mode, la modification du paramétrage est bloqué.
On verra dans la suite des tests effectué dans ce post, qu'il nous faudra activer / désactiver la case « Activer les ACL ». Il faudra donc définir le champs « Objectif » sur « No presets » pour modifier le paramétrage par défaut.

Capture___.PNG
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
DEBUT TESTS

Je précise que tous mes tests et paramétrages sont effectué à partir d’un PC fonctionnant sous Windows 10.
J’ai également testé l’accès aux partages via Android. Pour cela j’ai téléchargé l’application « Android Samba Client » qui permet de monter un partage SMB dans le navigateur de fichier d’Android.
En revanche, je n’ai pas pu effectuer de test à partir d’un PC fonctionnant sous Linux car je n’en avais pas sous la main.

Objectifs général des tests suivants : création d’un partage pour l’utilisateur Gabin afin que lui-même et les membre du groupe « parents » (Jean et Marie) aient toutes les autorisations.

Protocole testés dans chacun des tests suivants :
  • tentative de connexion au partage « gabin » avec chacun des utilisateurs suivants : Gabin, Jean, Marie
  • création d’un fichier texte avec chacun des utilisateur. (Donc chaque utilisateur a créé un fichier texte dans le dataset « gabin »)
  • manipulations réalisées sur les fichiers par chacun des 3 utilisateurs :
    • tentative de modifier le contenu des fichiers et d’enregistrer ;
    • tentative de modifier les noms de fichiers ;
    • tentative de suppression des fichiers.
ps : sur Windows, redémarrer le service « Station de travail » (« Workstation » en anglais) permet de déconnecter l’utilisateur identifié. Cela me permet de basculer d’un utilisateur à un autre, sans me déconnecter de la session en cours.


Création du dataset « gabin » avec les paramètres suivants :
  • Type de partage : Generic
  • Sensibilité à la casse : Insensitive
  • Mode ACL : Passthrough
En ce qui concerne la création du partage (Partages > Partages Windows (SMB) > Ajouter)
J’ai simplement sélectionné le chemin jusqu’au dataset « gabin », et j’ai laissé tous les paramètres par défaut dont le champs « Objectif » défini sur « Default share parameter ».
Au moment d’enregistrer, une fenêtre est apparue, me demandant de configurer les ACL, j’ai cliqué sur annulé et le partage a été créé avec les permissions UNIX. Comme je n’avais pas configuré d’ACL, je pense que le système a dû en générer automatiquement pour répondre à la « norme » du protocole, comme le montre la commande « getfacl » effectuée sur le dataset « gabin » (voir TEST 1)



Pour les différents tests, il m'a fallu passer des permissions UNIX aux ACLs et vice-et-versa.
Pour cela, Truenas propose deux «éditeurs» dans Stockage > Volumes > cliquer sur « Action » (3 points en bout de ligne du dataset souhaité) > modifier les autorisations >
Selon la configuration dans laquelle se trouve le dataset, quand la page d'édition des permissions s'affiche, on est :
  • soit en mode « éditeur classique » (permissions UNIX)
  • soit en mode « éditeur d'ACL »
Pour passer de l'un à l'autre il suffit de cliquer en bas de page sur le bouton « use permissions editor » ou « use ACL manager ».
Petite subtilité pour le passage de « ACL manager » à « Permissions editor » : si des ACLs ont été configurée, le boutons s'intitulera « Supprimer les ACLs ».


Dernier point avant de commencer les tests :
root@truenas[/mnt/TEST/gabin]# ls -l
-rw-r--r--+ gabin gabin gabin.txt

Dans certains tests, vous verrez apparaitre un petit signe « + » en bout des permissions.
Ce signe indique qu'il y a des droits ACL sur ce fichier. A priori, lorsque les ACLs sont utilisées, la commande "ls" ne reflète pas la réalité en matière de permissions. Dans ce cas, il faut obligatoirement utiliser les commandes « getfacl » et « setfacl » pour voir les droits effectifs.
Sources :
https://debian-facile.org/viewtopic.php?pid=367271#p367271




TEST 1
  • Mode ACL : passthrough
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents
Configuration des permissions (éditeur UNIX) :
  • user : rwx
  • group : rwx
  • other : ---

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : parents
owner@ : rwxp--aARWcCos :-------:allow
group@ : rwxp--a-R-c--s :-------:allow
everyone@ : ------a-R-c--s :-------:allow
root@truenas[~]#

Résultats :
Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rw-r--r-- gabin parents gabin.txt
-rw-r--r-- jean parents jean.txt
-rw-r--r-- marie parents marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir les fichiers de tous les utilisateurs du dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin, Jean et Marie ne peuvent modifier que le contenu du fichier dont ils sont propriétaire (celui qu’il ont créé)
  • Gabin, Jean et Marie ne peuvent modifier que le nom du fichier dont ils sont propriétaire (celui qu’il ont créé)
  • Gabin, Jean et Marie ne peuvent supprimer que le fichier dont ils sont propriétaire (celui qu’ils ont chacun créé)
En ce qui me concerne, le fonctionnement ne me convient pas du tout, pour une raison que j’ignore, les fichiers créés n’héritent pas du tout des autorisations définies sur le dataset.




TEST 2
  • Mode ACL : passthrough
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents
Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : parents
owner@: rwxpDdaARWcCos:fd-----:allow
group@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Résultat :
Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rw-r--r-- gabin parents gabin.txt
-rw-r--r-- jean parents jean.txt
-rw-r--r-- marie parents marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : parents
owner@ : rw-p--aARWcCos :-------:allow
group@ : r-----a-R-c--s :-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c- -s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin, Jean et Marie peuvent modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie ne peuvent modifier que le contenu du fichier dont ils sont propriétaire (celui qu’il ont créé)
  • Gabin, Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
Dans ce second test, la seule différence est que Gabin, Jean, et Marie peuvent supprimer un fichier dont il ne sont pas propriétaire.




TEST 3
  • Mode ACL : passthrough
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin
Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
owner@: rwxpDdaARWcCos:fd-----:allow
group@: rwxpDdaARWcCos:fd-----:allow
group:parents: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Résultat :
Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rw-r--r--+ gabin gabin gabin.txt
-rw-r--r--+ jean gabin jean.txt
-rw-r--r--+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c- -s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin, Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin ne peut modifier que le contenu du fichier dont il est propriétaire
  • Gabin, Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
Dans ce troisième test, on peut rajouter le fait que les membres du groupe propriétaire peuvent modifier les fichiers dont ils ne sont pas propriétaire.

On se rapproche de ce que je souhaite réaliser, mais, on n’y est pas encore.
Pourquoi l’utilisateur propriétaire du dataset ne peut-il pas modifier les fichiers créés par les membres du groupe propriétaire de ce même dataset ?




TEST 4

Modification du paramètre « ACL Mode » du dataset dans Stockage > Volume > cliquer sur « Action » (3 points en bout de ligne du dataset souhaité) > modifier les options > cliquer sur le bouton « Options avancées » > champ « ACL Mode » > Restricted

Vérification de la bonne prise en compte du paramètre :
root@truenas[~]# zfs list -o aclmode /mnt/TEST/gabin
ACLMODE
restricted
root@truenas[~]#
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents

Configuration des permissions (éditeur UNIX) :
  • user : rwx
  • group : rwx
  • other : ---

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : parents
owner@: rwxp--aARWcCos:-------:allow
group@: rwxp--a-R-c--s:-------:allow
everyone@: -----a-R-c--s:-------:allow
root@truenas[~]#

Résultat :
Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rw-r--r-- gabin parents gabin.txt
-rw-r--r-- jean parents jean.txt
-rw-r--r-- marie parents marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : parents
owner@ : rw-p--aARWcCos :-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : parents
owner@ : rw-p--aARWcCos:-------:allow
group@ : r-----a-R-c--s:-------:allow
everyone@ : r-----a-R-c--s:-------:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement : résultats identiques au TEST 1.




TEST 5
  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents
Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : parents
owner@: rwxpDdaARWcCos:fd-----:allow
group@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Résultat :
Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin parents gabin.txt
-rwxrwx---+ jean parents jean.txt
-rwxrwx---+ marie parents marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : parents
owner@ : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : parents
owner@ : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : parents
owner@ : rwxpDdaARWcCos :------I:allow
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
On peut s’apercevoir ici que les droits sur les fichiers ont changés par rapport au TEST 2

Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin ne peut voir que le fichier dont il est propriétaire. Il ne voit pas les fichiers créés par Jean et Marie. Donc Gabin ne peut réaliser aucune autre opération sur les fichiers dont il n’est pas propriétaire car les fichiers ne sont pas visibles.
  • Gabin peut seulement lire le contenu du fichier, modifier le nom du fichier, modifier le contenu du fichier et supprimer le fichier dont il est propriétaire
  • Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
Dans ce test, j'avoue ne pas bien comprendre pourquoi l'utilisateur Gabin ne peut voir et agir que sur les fichiers dont il est propriétaire.
Si vous avez une explication, ...





TEST 6
  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage
root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
owner@: rwxpDdaARWcCos:fd-----:allow
group@: rwxpDdaARWcCos:fd-----:allow
group:parents: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#


Résultat :
Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
-rwxrwx---+ jean gabin jean.txt
-rwxrwx---+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
owner@ : rwxpDdaARWcCos :------I:allow
group@ : rwxpDdaARWcCos:------I:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin, Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)

Ce dernier test est le fonctionnement de ce que je recherche.
Quid du groupe « everyone@ », faut-il ne rien mettre, ou interdire l’accès ?


Point sur les tests effectué à partir d'Android : je me suis connecté aux partages à partir de l'utilisateur Jean.
Je pouvais voir les fichiers de chacun des utilisateur
Je pouvais ouvrir les fichiers, mais à l'intérieur, selon l'application (éditeur de texte) utilisé, soit le fichier était vide, soit je pouvais voir le contenu.
=> très bizarre.
Dans tous mes tests sans exception, impossible d'enregistrer une modification.
J'ai pu en revanche sur certains tests, supprimer les fichiers.
Le comportement sur Android est très bizarre, est-ce que ce sont les applications elles-même qui sont en cause, les autorisations des applications paramétrées, autre chose,...???

Pour valider mon paramétrage des ACLs, il me sera nécessaire de tester mon partage avec un PC fonctionnant sous Linux.



-----------------
FIN DES TESTS
-----------------

Dans mon cas d’application, j’ai décidé de procéder autrement en ce qui concerne le propriétaire d’un dataset.
En effet, lorsque j’étais sous Freenas 9.3 et qu’on pouvait utiliser les droits UNIX pour réaliser un partage SMB, il fallait parfois utiliser des utilisateurs et groupes spéciaux comme propriétaire d’un dataset.
Typiquement mon dataset « Medias » avait comme utilisateur propriétaire « nobody » et comme groupe propriétaire « nogroup ».

Je pense donc créer un utilisateur et un groupe propriétaire, par exemple « gijo:gijo » qui seront propriétaires de tous mes datasets et qui auront les autorisation « full control ».
Si je reprends mon exemple avec le Gabin, cela ressemblerait à :
  • dataset : gabin
  • utilisateur propriétaire : gijo
  • groupe propriétaire : gijo
Configuration des entrées ACLs :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • utilisateur:gabin : autoriser – modification – héritage
  • group:parents : autoriser – modification – héritage
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Dans cette section, voyons l'effet d'un refus de type « contrôle total » configuré sur le groupe « everyone@»


TEST 7

  • Mode ACL : restricted
  • dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin
Configuration des entrées ACLs :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage
  • everyone@ : refuser – contrôle total – héritage
root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
everyone@: rwxpDdaARWcCos:fd-----:deny
owner@: rwxpDdaARWcCos:fd-----:allow
group@: rwxpDdaARWcCos:fd-----:allow
group:parents: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

⇒ Impossible de se connecter au partage quel que soit l’utilisateur.

Donc, on s’aperçoit que même si le propriétaire et le groupe propriétaire ont le contrôle total sur le dataset, « everyone@ » qui a été défini en « refuser le contrôle total » prends la prépondérance.
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Bonjour,

Dans cette section, nous allons voir l'effet de la case « Activer ACL » disponible dans : Partages > Partages Windows (SMB) > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Modifier > Options avancées > Paragraphe « Accès » > Case « Activer les ACL ».

Avant toute chose, si le paramétrage est bloqué (non modifiable), il faut modifier le champ « Objectif" qui se trouve normalement juste au dessus.
Pour ma part, ce champ est défini par défaut sur « Default share parameter ». Pour rendre accessible la case « Activer les ACL », j'ai défini ce champs sur « No Presets ».

Si des ACLs existent sur le partage, lorsque vous décocherez la case, un message apparaitra informant qu'une ACL est détectée sur le chemin d'accès et que les ACL doivent être supprimées si on ne souhaite pas utiliser les ACLs.
Pour décocher la case, il faut donc se rendre :
  • soit dans : Partages > Partages Windows (SMB) > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Modifier l'ACL du système de fichier
  • soit dans : Stockage > Volumes > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Paragraphe « Actions dataset » > modifier les autorisations

=> Cliquer sur le bouton « Supprimer les ACLs » en bas de page (confirmer la suppression)

On peut ensuite retourner sur la page initiale et décocher la case « Activer les ACL ».
Désactiver cette fonction suppose finalement de n'utiliser que les permissions UNIX.

De ce fait, voyons les effets de désactiver cette option. Pour ce faire, je me suis remis dans les conditions des tests 1 et 4 , mais avec la case « Activer ACL » décoché.



Voici les résultats :


TEST 8 (paramétrage identique au TEST 1)

  • Mode ACL : passthrough
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents

Configuration des permissions (éditeur UNIX) :
  • user : rwx
  • group : rwx
  • other : ---

Le résultat des commandes « getfacl » et « ls -l » sont identiques à ceux du TEST 1

J'ai détecté une seule différence de comportement :
Dans le TEST 1, Gabin, Jean et Marie ne peuvent supprimer que le fichier dont ils sont propriétaire.
Dans ce TEST 4, Gabin, le propriétaire du dataset peut supprimer les fichiers de n'importe quel utilisateur.




TEST 9 (paramétrage identique au TEST 4)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents

Configuration des permissions (éditeur UNIX) :
  • user : rwx
  • group : rwx
  • other : ---
Le résultat des commandes « getfacl » et « ls -l » sont identiques à ceux du TEST 4 (et donc à ceux du TEST1, puisque TEST4 = TEST1)

J'ai détecté deux différences de comportement :
  • Dans le TEST 1, Gabin, Jean et Marie ne peuvent modifier que le nom du fichier dont ils sont respectivement propriétaire. Dans ce TEST 9, Gabin, le propriétaire du dataset, peut modifier le nom de n'importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Dans le TEST 1, Gabin, Jean et Marie ne peuvent supprimer que le fichier dont ils sont respectivement propriétaire. Dans ce TEST 9, Gabin, le propriétaire du dataset, peut supprimer n'importe quel fichier du dataset (quel que soit le propriétaire du fichier)


Par ailleurs, si vous définissez des ACLs par la suite alors que la case « Activer les ACL » est décochée, normalement, Windows affichera un message d'erreur information qu'on ne dispose pas des autorisations nécessaires. La connexion au partage sera impossible. Il suffira donc de recocher la case pour que le partage soit accessible.

Ce qu'il faut retenir :
La case « Activer les ACL » ne s'utilise que si on utilise les droits UNIX.
Du coup je ne comprends pas pourquoi on peut utiliser les droits UNIX lorsque cette case est cochée.
Cette options est un peu mystérieuse à mon sens.
Peut-être qu'il y a d'autre différences de comportements ou d'autres effets non-visibles que je n'ai pas détecté.
Si vous avez davantage d'informations au sujet de cette option, elles seront les bienvenues.
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Dans cette section, nous allons voir l'influence de l'héritage (inherit) des droits.

Les tests ont uniquement été effectué en mode ACL de type « Restricted » car cela aurait fait beaucoup trop de test. Et je ne suis pas sûr que le mode « Passthrough » soit pertinent.
(Stockage > Volumes > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Paragraphe « Actions dataset » > modifier les options > Paragraphe « Autres options » > Mode ACL : Restricted)

Tout d'abord, il apparait lorsque l'on configure des ACLs, il soit nécessaire qu'il y ait moins un ACL défini avec un héritage (inherit). Dans le cas contraire un message en rouge informe qu'un ACL doit obligatoirement est défini avec un héritage.





TEST 10 (paramétrage similaire au TEST 5)
  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents
Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – pas d’héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : parents
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwx------+ gabin parents gabin.txt
-rwx------+ jean parents jean.txt
-rwx------+ marie parents marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : parents
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : parents
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : parents
owner@ : rwxpDdaARWcCos :------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie ne peuvent voir que les fichiers dont ils sont propriétaire. Ils ne voient donc que le fichier qu'ils ont chacun respectivement créé. Gabin, Jean et Marie ne peuvent donc réaliser aucune autre opération sur les fichiers dont ils ne sont pas propriétaire car les fichiers ne sont pas visibles.
  • Gabin, Jean et Marie peuvent lire le contenu du fichier, modifier le contenu du fichier, modifier le nom du fichier et supprimer le fichier dont il sont propriétaire.

Cas d'application :
Je pense qu'un tel cas d'application pourrais convenir par exemple à un dataset dans lequel chaque utilisateur pourrais avoir son dossier personnel.
Attention : si deux utilisateurs tentent de créer chacun un fichier portant le même nom à la racine du dataset, seul l'un deux y parviendra. L'autre aura un message d'erreur disant que cela n'est pas possible. En effet, même s'il ne le voit pas, le fichier portant le même nom existe.





TEST 11 (paramétrage similaire au TEST 5)
  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : parents

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – pas d’héritage
  • group@ : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : parents
owner@: rwxpDdaARWcCos:-------:allow
group@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
----rwx---+ gabin parents gabin.txt
----rwx---+ jean parents jean.txt
----rwx---+ marie parents marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : Nouveau document texte.txt
#owner : gabin
#group : parent
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : parents
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : parents
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#

Concrètement :
  • Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin peut créer un fichier dans le dataset « gabin », en revanche, il ne peut pas le nommer. Le fichier prend le nom par défaut suivant « Nouveau document texte.txt »
  • Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin ne peut voir que le fichier dont il est propriétaire. Gabin ne peut réaliser aucune autre opération sur les fichiers dont il n’est pas propriétaire car les fichiers ne sont pas visibles.
  • Gabin ne peut ni ouvrir, ni modifier le nom du fichier, ni modifier le contenu du fichier, ni supprimer le fichier qu’il a lui-même créé
  • Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)

Cas d'application :
Je ne vois pas de réel intérêt à une configuration où le propriétaire d'un dataset ne peut y réaliser aucune opération.





TEST 12 (paramétrage similaire au TEST 6)
  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – pas d’héritage
  • group:parents : autoriser – contrôle total – pas d’héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
group@: rwxpDdaARWcCos:-------:allow
group:parents : rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwx------+ gabin gabin gabin.txt
-rwx------+ jean gabin jean.txt
-rwx------+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie ne peuvent voir que les fichiers dont ils sont propriétaire. Ils ne voient donc que le fichier qu'ils ont chacun respectivement créé. Gabin, Jean et Marie ne peuvent donc réaliser aucune autre opération sur les fichiers dont ils ne sont pas propriétaire car les fichiers ne sont pas visibles.
  • Gabin, Jean et Marie peuvent lire le contenu du fichier, modifier le contenu du fichier, modifier le nom du fichier et supprimer le fichier dont il sont propriétaire.
Nous sommes ici dans une situation de fonctionnement comparable au TEST 10.

Cas d'application : voir TEST 10





TEST 13 (paramétrage similaire au TEST 6)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – pas d’héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
group:parents : rwxpDdaARWcCos:-------:allow
group@: rwxpDdaARWcCos:fd-----:allow
owner@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
-rwxrwx---+ jean gabin jean.txt
-rwxrwx---+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
group@ : rwxpDdaARWcCos:------I:allow
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
group@ : rwxpDdaARWcCos:------I:allow
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
group@ : rwxpDdaARWcCos:------I:allow
owner@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Jean, Marie et Gabin ne peuvent voir que les fichiers dont ils sont propriétaire. Ils ne voient donc que leur propre fichier. Donc Gabin, Jean et Marie ne peuvent réaliser aucune autre opération sur les fichiers dont ils ne sont pas propriétaire car les fichiers ne sont pas visibles.
  • Gabin, Jean et Marie peuvent lire le contenu du fichier, modifier le contenu du fichier, modifier le nom du fichier et supprimer le fichier dont il sont propriétaire.
Nous sommes ici encore dans une situation de fonctionnement comparable au TEST 10 et 12.

Cas d'application : voir TEST 10





TEST 14 (paramétrage similaire au TEST 6)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@: autoriser – contrôle total – pas d’héritage
  • group@: autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
owner@: rwxpDdaARWcCos:-------:allow
group:parents : rwxpDdaARWcCos:fd-----:allow
group@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
----rwx---+ gabin gabin gabin.txt
----rwx---+ jean gabin jean.txt
----rwx---+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin, Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)

Cas d'application :
Ici, nous avons un cas où le fonctionnement est identique au TEST 6.
Ce qui parait logique car même si les fichiers n'héritent pas des droits de l'utilisateur propriétaire, ils héritent des droits du groupe propriétaire auquel fait parti l'utilisateur propriétaire. Je pense qu'il y aurait eu des différences si les droits du groupe propriétaires auraient été différent de ceux de l'utilisateur propriétaire. (voir TEST 18)





TEST 15 (paramétrage similaire au TEST 6)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – pas d’héritage
  • group@ : autoriser – contrôle total – pas d’héritage
  • group:parents : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
owner@: rwxpDdaARWcCos:-------:allow
group@: rwxpDdaARWcCos:-------:allow
group:parents : rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
----------+ gabin gabin gabin.txt
----------+ jean gabin jean.txt
----------+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : Nouveau document texte.txt
#owner : gabin
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin peut créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin », en revanche, il ne peut pas le nommer. Le fichier prend le nom par défaut suivant « Nouveau document texte.txt »
  • Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin ne peut voir que le fichier dont il est propriétaire. Gabin ne peut réaliser aucune autre opération sur les fichiers dont il n’est pas propriétaire car les fichiers ne sont pas visibles.
  • Gabin ne peut ni lire le contenu du fichier, ni modifier le nom du fichier, ni modifier le contenu du fichier, ni supprimer le fichier dont il est propriétaire
  • Jean et Marie peuvent chacun lire tous les fichiers contenus dans le dataset
  • Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)

Nous sommes ici dans un cas de fonctionnement identique au TEST 11.

Cas d'application : voir le TEST 11





TEST 16 (paramétrage similaire au TEST 6)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – pas d’héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – pas d’héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
owner@: rwxpDdaARWcCos:-------:allow
group:parents : rwxpDdaARWcCos:-------:allow
group@: rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
----rwx---+ gabin gabin gabin.txt
----rwx---+ jean gabin Nouveau document texte.txt
----rwx---+ marie gabin Nouveau dossier compressé.zip
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : Nouveau document texte.txt
#owner : jean
#group : gabin
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : Nouveau dossier compressé.zip
#owner : marie
#group : gabin
group@ : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Gabin peut créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Jean et Marie peuvent créer un fichier dans le dataset « gabin », en revanche, il ne peuvent pas le nommer. Le fichier prend le nom par défaut « Nouveau document texte.txt ». Par ailleurs, si Jean a créé un document texte en premier, Marie ne pourra pas créé un autre document texte car il lui sera impossible de lui donner un autre nom. Elle peut toutefois créer un autre type de document comme un .odt vierge qui aura un nom par défaut différent.
  • Gabin peut voir tous les fichiers contenus dans le dataset
  • Jean et Marie ne peuvent voir que le fichier dont ils sont chacun propriétaire. Jean et Marie ne peuvent donc réaliser aucune autre opération sur les fichiers dont ils ne sont pas propriétaire car les fichiers ne sont pas visibles.
  • Jean et Marie ne peuvent ni lire le contenu du fichier, ni modifier le nom du fichier, ni modifier le contenu du fichier, ni supprimer le fichier dont ils sont respectivement propriétaires.
  • Gabin peut lire le contenu de n'importe quel fichiers du dataset
  • Gabin peut modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin peut modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin peut supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)

Cas d'application :
Ce cas d'application n'a pas de réel intérêt à mon sens.





TEST 17 (paramétrage similaire au TEST 6)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – pas d’héritage
  • group:parents : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:fd-----:allow
group:parents : rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwx------+ gabin gabin gabin.txt
-rwx------+ jean gabin jean.txt
-rwx------+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
owner@ : rwxpDdaARWcCos:------I:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin ne peut voir que le fichier dont il est propriétaire. Gabin ne peut donc réaliser aucune autre opération sur les fichiers dont il n’est pas propriétaire car les fichiers ne sont pas visibles.
  • Jean et Marie peuvent chacun lire tous les fichiers contenus dans le dataset
  • Gabin peut seulement lire le contenu du fichier, modifier le nom du fichier, modifier le contenu du fichier et supprimer le fichier dont il est propriétaire
  • Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)





TEST 18 (paramétrage similaire au TEST 6)

  • Mode ACL : restricted
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – pas d’héritage
  • group@ : autoriser – Lecture – héritage
  • group:parents : autoriser – contrôle total – héritage

root@truenas[~]# getfacl /mnt/TEST/gabin
#file : /mnt/TEST/gabin
#owner : gabin
#group : gabin
owner@: rwxpDdaARWcCos:-------:allow
group@: r-x---a-R-c---:fd-----:allow
group:parents : rwxpDdaARWcCos:fd-----:allow
everyone@: -------------:fd-----:allow
root@truenas[~]#

Un petit « ls -l » sur les fichiers créés donne :
root@truenas[/mnt/TEST/gabin]# ls -l
----r-x---+ gabin gabin gabin.txt
----r-x---+ jean gabin jean.txt
----r-x---+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#
et un « getfacl » :
root@truenas[/mnt/TEST/gabin]# getfacl gabin.txt
#file : gabin.txt
#owner : gabin
#group : gabin
group@: r-x---a-R-c---:-------:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
#file : jean.txt
#owner : jean
#group : gabin
group@: r-x---a-R-c---:-------:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
#file : marie.txt
#owner : marie
#group : gabin
group@: r-x---a-R-c---:fd-----:allow
group:parents : rwxpDdaARWcCos:------I:allow
everyone@ : --------------:------I:allow
root@truenas[/mnt/TEST/gabin]#


Concrètement :
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin ne peut pas modifier le contenu d’un fichier, quel que soit le propriétaire, y compris les fichiers dont il est le propriétaire. En revanche, il peut enregistrer les modifications sous un nouveau fichier
  • Gabin, Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)

Voici comment j’interprète le comportement relevé :
Comme le propriétaire (Gabin) a le droit d’écriture, il peut créer le fichier. Toutefois le fichier, n’hérite que des droits du groupe propriétaire (Gabin) qui n’a lui que le droit en lecture.






Qu'en retenir :
Après ces nombreux tests, j'en comprends que la notion d'héritage consiste à ce que les repertoires / fichiers contenus dans le dataset détiennent uniquement les droits des utilisateurs et groupes où l'héritage a été défini.

J'avoue que je n'arrive pas bien à saisir dans quels cas d'utilisation ne pas appliquer l'héritage des droits.
edit : J'ai posé la question sur le forum principal (ici).
Pour résumer, "no inherit" est à utiliser avec l'autorisation "Traverser".
Par exemple, lorsque que l'on veut qu'un utilisateur ou un groupe d'utilisateur puisse accéder à des sous-dataset sur lesquels ils ont des droits, alors qu'ils n'ont pas d'autorisation (lecture / écriture notamment) sur le dataset parent.


L'ACL "Home" proposé par Truenas utilise le drapeau "no inherit" :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – modification – pas d'héritage
  • evryone@ : autoriser – traverser – pas d'héritage
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Appliquer le propriétaire / groupe à tous les fichiers contenus dans un dataset

Je vais ici évoquer la fonction « Appliquer les autorisations de manière récursives » disponible à partir de :
  • Partages > Partages Windows (SMB) > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Modifier l'ACL du système de fichier > paragraphe « Avancé » > case « Appliquer les autorisations de manière récursives »
  • Stockage > Volumes > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Paragraphe « Actions dataset » > modifier les autorisations > paragraphe « Avancé » > case « Appliquer les autorisations de manière récursives »

TEST 19 : propagation de l'utilisateur propriétaire et/ou du groupe propriétaire du dataset à tous les fichiers/répertoires de ce dataset

Reprenons notre configuration du TEST 6 :
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin
Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage
Ci-dessous le contenu du dataset « gabin » :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
-rwxrwx---+ jean gabin jean.txt
-rwxrwx---+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#

Comme nous pouvons le constater, nous avons 3 fichiers qui ont chacun un propriétaire différent.
Si nous souhaitons que tous les fichiers (y compris ceux contenus dans d'éventuels sous-répertoires) aient comme propriétaire, l'utilisateur propiétaire du dataset (dans notre acs "Gabin"), il suffit de :
  1. dans le paragraphe « Informations sur le fichier » > Utilisateur > cocher la case « Appliquer Utilisateur »
  2. dans le paragraphe « Avancé » > cocher la case « Appliquer les autorisations de manière récursives »
  3. confirmer le choix lorsque la boite de dialogue d'alerte « Attention : Le paramétrage des autorisations affecte récursivement ce répertoire et tous les autres sous ce répertoire. Cela peut rendre les données inaccessibles. » apparait.
  4. cliquer le bouton « Enregistrer »
Ci-dessous le nouveau contenu du dataset « gabin » :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
-rwxrwx---+ gabin gabin jean.txt
-rwxrwx---+ gabin gabin marie.txt
root@truenas[/mnt/TEST/gabin]#




TEST 20 : propagation d'une modification de droits fichiers/répertoires contenus dans un dataset

Reprenons notre configuration du TEST 6 :
  • Dataset : gabin
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin
Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage
root@truenas[~]# getfacl /mnt/TEST/gabin
# file: /mnt/TEST/gabin
# owner: gabin
# group: gabin
group@: rwxpDdaARWcCos:fd-----:allow
owner@: rwxpDdaARWcCos:fd-----:allow
group:parents: rwxpDdaARWcCos:fd-----:allow
everyone@: --------------:fd-----:allow
root@truenas[~]#

Un « ls -l » sur le dataset « gabin » donne :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
drwxrwx---+ marie gabin dossier
-rwxrwx---+ marie gabin marie.txt
root@truenas[/mnt/TEST/gabin]#

Un « getfacl » sur l'un des fichier donne :
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
# file : marie.txt
# owner : marie
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: rwxpDdaARWcCos:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#




Procédons à un changement sur les permissions ACLs :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – modifier – héritage
=> Enregistrer sans cocher la case « Appliquer les autorisations de manière récursives »

root@truenas[~]# getfacl /mnt/TEST/gabin
# file: /mnt/TEST/gabin
# owner: augustin
# group: augustin
group@: rwxpDdaARWcCos:fd-----:allow
owner@: rwxpDdaARWcCos:fd-----:allow
group:parents: rwxpDdaARWc--s:fd-----:allow
everyone@: --------------:fd-----:allow
root@truenas[~]#
On peut voir que les permissions du groupe « parents » ont changés.

L'utilisateur « Jean » créé un nouveau fichier « jean.txt » dans le dataset « gabin »
Regardons maintenant les fichiers contenus dans le dataset « gabin » avec la commande « ls -l » :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
drwxrwx---+ marie gabin dossier
-rwxrwx---+ marie gabin marie.txt
-rwxrwx---+ jean gabin jean.txt
root@truenas[/mnt/TEST/gabin]#

Un « getfacl » sur les fichiers « marie.txt » et « jean.txt » donne :
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
# file : marie.txt
# owner : marie
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: rwxpDdaARWcCos:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
# file : jean.txt
# owner : jean
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: rwxpDdaARWc--s:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#

On s'aperçoit que seuls les fichiers nouvellement créés reçoivent les nouveaux droits. Les fichiers/répertoires déjà présents sont restés avec les droits initiaux.





Procédons à un nouveau changement sur les permissions ACLs :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – lecture – héritage
=> Enregistrer en cochant cette fois-ci la case « Appliquer les autorisations de manière récursives »

root@truenas[~]# getfacl /mnt/TEST/gabin
# file: /mnt/TEST/gabin
# owner: augustin
# group: augustin
group@: rwxpDdaARWcCos:fd-----:allow
owner@: rwxpDdaARWcCos:fd-----:allow
group:parents: r-x---a-R-c---:fd-----:allow
everyone@: --------------:fd-----:allow
root@truenas[~]# cd /mnt/TEST/gabin
On peut voir que les permissions du groupe « parents » ont de nouveau changés.

Regardons maintenant les fichiers contenus dans le dataset « gabin » avec la commande « ls -l » :
root@truenas[/mnt/TEST/gabin]# ls -l
-rwxrwx---+ gabin gabin gabin.txt
drwxrwx---+ marie gabin dossier
-rwxrwx---+ marie gabin marie.txt
-rwxrwx---+ jean gabin jean.txt
root@truenas[/mnt/TEST/gabin]#

Un « getfacl » sur les fichiers « marie.txt » et « jean.txt » donne :
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
# file : marie.txt
# owner : marie
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: r-x---a-R-c---:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
# file : jean.txt
# owner : jean
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: r-x---a-R-c---:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#

Ici, on s'aperçoit que les droits ont été propagé à tous les fichiers / répertoires contenus dans le datatset « gabin »

***voir post suivant
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
***
Le dernier volet de mon TEST 20 (test précédent) a fait ressortir un comportement que je n'avais pas décelé sur aucun autre test.

Comportement AVANT

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – contrôle total – héritage
root@truenas[/mnt/TEST/gabin]# getfacl marie.txt
# file : marie.txt
# owner : marie
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: rwxpDdaARWcCos:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#
  • Gabin, Jean et Marie peuvent chacun créer un fichier vierge (clic droit > nouveau > document texte) dans le dataset « gabin »
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin, Jean et Marie peuvent chacun modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Gabin, Jean et Marie peuvent chacun supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)




Comportement APRES

Configuration des permissions (éditeur ACL) :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – contrôle total – héritage
  • group:parents : autoriser – lecture – héritage
root@truenas[/mnt/TEST/gabin]# getfacl jean.txt
# file : jean.txt
# owner : jean
# group : gabin
group@: rwxpDdaARWcCos:-------:allow
owner@: rwxpDdaARWcCos:-------:allow
group:parents: r-x---a-R-c---:-------:allow
everyone@: --------------:-------:allow
root@truenas[/mnt/TEST/gabin]#
  • Gabin, Jean et Marie peuvent chacun voir tous les fichiers contenus dans le dataset
  • Gabin, Jean et Marie peuvent chacun lire le contenu de n'importe quel fichier du dataset
  • Gabin peut modifier le contenu de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie ne peuvent modifier que le contenu du fichier dont ils sont chacun respectivement propriétaire
  • Gabin peut modifier le nom de n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie ne peuvent modifier aucun nom de fichier du dataset (quel que soit le propriétaire du fichier, y compris celui dont il est propriétaire)
  • Gabin peut supprimer n’importe quel fichier du dataset (quel que soit le propriétaire du fichier)
  • Jean et Marie ne peuvent supprimer que le fichier dont ils sont le, propriétaire
Je ne comprends pas du tout ce comportement.
En effet, je ne comprends pas pourquoi Jean et Marie peuvent modifier le contenu du fichier dont ils sont propriétaire et supprimer ce même fichier, étant donné qu'ils font parti du groupe "parents" et que ce groupe ne possède que les droits en lecture.

Autre théorie :
Jusqu'ici j'ai toujours considéré que lorsque je fais un « getfacl » sur un fichier, le "owner@" et le "group@" représente les autorisations du propriétaire et du groupe propriétaire du dataset.
Or peut-être que le "owner@" et le "group@" sont en fait le propriétaire et le groupe propriétaire du fichier en question. Ce qui explique que Jean et Marie puissent modifier le contenu et supprimer le fichier dont ils sont chacun respectivement propriétaire, mais pas celui des autres.
Mais du coup, je n'explique pas le fait que Jean et Marie ne puissent pas modifier le nom du fichier dont ils sont chacun respectivement propriétaire.

Si vous avez une explication ...
 
Last edited:

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Gestion des fichiers temporaires

Lorsque nous mettons en place des partages SMB apparaissent tout une ribambelles de fichiers cachés ou temporaires. La plupart d'entre-eux sont des fichiers commençant par un « . », tels que « .Trashes », « .DS_Store »,...
Il est possible de rendre ces fichiers invisibles sur le poste client. Attention, ils ne seront pas supprimés, seulement cachés.
Pour cela, se rendre dans : Stockage > Volumes > sélectionner un partage > cliquer sur les 3 points verticaux (en bout de ligne) pour accéder au menu déroulant > Paragraphe « Actions dataset » > modifier > cliquer sur le bouton « Options avancées » > Paragraphe « Autres options » > Champs « Paramètres auxiliaires » > insérer la ligne :
  • veto files = /Temporary Items/.DS_Store/.AppleDB/.TemporaryItems/.AppleDouble/.bin/.AppleDesktop/Network Trash Folder/.Spotlight/.Trashes/.fseventd/.cshrc/.login/.login_conf/.mail_aliases/.mailrc/.profile/.rhosts/.shrc
Cette opération est à réaliser sur chaque partage SMB.

J'attire votre attention sur la conséquence d'ajouter l'option « veto files » à un partage SMB : lorsqu'un utilisateur tentera de supprimer un répertoire, il pourra se voir refuser cette action. En effet, quand bien même le répertoire semblera vide du point de vue de l'utilisateur, les fichiers cachés sont toujours présents et empêchent par défaut la suppression du répertoire dans lequel ils résident.
Pour désactiver cette protection, il suffit d'ajouter le paramètre suivant à la ligne suivante du « veto files »
  • delete veto files = yes
Si la valeur est « yes », le répertoire et les fichiers soumis à un veto seront supprimés.

Nous aurons donc le champs « paramètres auxiliaires » qui ressemblera à ceci :
veto files = /Temporary Items/.DS_Store/.AppleDB/.TemporaryItems/.AppleDouble/.bin/.AppleDesktop/Network Trash Folder/.Spotlight/.Trashes/.fseventd/.cshrc/.login/.login_conf/.mail_aliases/.mailrc/.profile/.rhosts/.shrc
delete veto files = yes

Sources :
https://www.durindel.fr/informatique/tuto-freenas-9-3-ajout-de-partages-pour-windows
https://www.linuxtopia.org/online_b...ation_guides/using_samba_book/ch05_02_12.html
 

Didus69

Cadet
Joined
Jan 23, 2023
Messages
7
Bonjour,
En premier lieu merci de ce retour conséquent et du temps passé à comprendre tout cela et à le rédiger.
j'ai passé du temps à la lecture et suis aux premiers tests seulement... au début donc et déjà la somme des infos, même si j'ai pas mal de "notions" commence à me submerger et je dois faire une pause, alors je vais poser ma question qui me semble en droit fil des droits ACL:

nouveau sur TrueNas Scale, j'ai monté un petit bloc de 4 disques en raidz1 pour faire des tests avant de faire ma config définitive, pas mal de blocages et des réponses trouvées sur le net, mais là, aprés avoir créé quelques partages et quelques utilisateurs j'ai installé transmission (client torrent) que j'utilise sur d'autres NAS commerciaux, Synolgy, Qnap ou Asustor, mais malgré tous mes efforts et les essais de compréhension à la lecture des posts relatant ce type d'erreur, tous en anglais, je suis bloqué, une ou deux lectures me pousseraient vers mediavault mais je refuse de baisser les bras pour un déni d'écriture...
j'ai créé un utilisateur spécifique, un groupe spécifique, créé les répertoires configurés dans transmission, mais j'ai toujours le message d'erreur en rouge sur le fichier
error: read only file systeme (chemin/nomdufichiertelechargé)


j'en suis déjà à une bonne dizaine d'heures rien que pour pouvoir faire écrire transmission dans le répertoire downloads, sans résultat, trés déçu de ce logiciel qui me paraissait si prometteur, mes partages windows et mes accès réseau fonctionnent bien


nb: si ce post vient polluer le fil, je peux le supprimer, mais merci de me répondre sur mon fil de discussion
 

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Bonjour,
Je suis désolé, mais mes connaissances sur les ACLs sont limitées à ce que j'ai posté dans ce fil de discussion.
J'avoue que je ne vais vous être d'un grand secours pour votre problème.
 

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Réalisation d'un partage "PUBLIC" accessible sans identification

Lors de la création du Partage : Partages > Partages Windows (SMB) > Ajouter > , il faudra, contrairement à des partages plus spécifiques, cocher la case "Autoriser l'accès invité".
  • Mode ACL : restricted
  • Dataset : public
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin

Configuration des permissions (éditeur ACL) :
Pour ce cas de figure, il est plus simple d'utiliser l'ACLs pré-définis "Open" qui configure les autorisations de la manière suivante :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – modification – héritage
  • everyone@ : autoriser – modification – héritage
Si par hasard, vous supprimez l'ACL "everyone@", le partage ne sera plus du tout accessible.
1675000422818.png

Un détails me chiffonne ici ; pour moi, Gabin (le propriétaire du dataset) devrait pouvoir se connecter, mais visiblement il n'a pas le droit.
 

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Réalisation d'un partage "PUBLIC" nécessitant une authentification

En réalité, le partage n'est pas réellement public, puisqu'il ne sera accessible qu'aux utilisateurs existants dans Truenas. Mais il sera accessible par tous les utilisateurs existants dans Truenas.
Nous sommes donc dans la même configuration que le post #11 ci-dessus, à une différence : lors de la création du partage ; dans Partages > Partages Windows (SMB) > Ajouter > il ne faudra pas cocher la case "Autoriser l'accès invité".
=> il faut faudra simplement laisser les paramètres par défaut.
  • Mode ACL : restricted
  • Dataset : public
  • utilisateur propriétaire : gabin
  • groupe propriétaire : gabin
Configuration des permissions (éditeur ACL) :
Pour ce cas de figure, il est plus simple d'utiliser l'ACLs pré-définis "Open" qui configure les autorisations de la manière suivante :
  • owner@ : autoriser – contrôle total – héritage
  • group@ : autoriser – modification – héritage
  • everyone@ : autoriser – modification – héritage
 

Didus69

Cadet
Joined
Jan 23, 2023
Messages
7
Merci des retours mais sous windows, tout semble bien se passer niveau droits, je vais tenter autre chose commencer par créer utilisateur donc répertoire puis groupe "downloads" vois si cela change quelque chose..
et je vais replonger dans les ACL....
 

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Agissement du propriétaire d'un dataset sur son propre dataset
C'est peut-être logique, mais sachez que si vous définissez l'utilisateur "Gabin" comme propriétaire d'un "dataset". Selon le type d'ACL que vous lui configurez, il n'aura pas forcément les pleins droits sur le dataset sur lequel il est propriétaire.
Exemple : si vous définissez un ACL de lecture à "Gabin", il n'aura que les droits en lecture, alors qu'il est propriétaire de ce dataset.
En gros, c'est comme en immobilier, c'est pas parce que vous être propriétaire d'une maison, que vous pouvez en jouir en totalité (c'est votre locataire qui a ces droits).
 

Paul042020

Contributor
Joined
May 4, 2020
Messages
118
Accès aux différentes versions d'un fichier
Si vous avez configuré des "Instantanés" de vos datasets qui sont partagé via SMB, il est possible d'accéder aux différentes versions d'un fichier à partir de l'explorateur Windows. (Linux ?)
Pour cela, il suffit :
d'ouvrir l'explorateur de fichier > se rendre dans le répertoire contenant le fichier en question > cliquer-droit sur le fichier en question > cliquer sur "Propriété" > cliquer sur l'onglet " Versions précédentes" > double-cliquer sur la version souhaitée pour l'ouvrir > enregistrer une copie.


Si aucune version n'est disponible dans l'onglet "Versions précédentes", deux causes peuvent en être la source :

1] soit il n'y a plus de versions disponibles. Cela varie grandement selon la durée de rétention de vos instantanés.
Exemple : vous faites un instantané tous les jours avec une durée de rétention d'une semaine. Si vous cherchez à récupérer une version d'un fichier qui date de deux semaines, je pense que c'est foutu par cette méthode. (se tourner vers vos sauvegardes externe, si vous en avez, et si elles sont plus anciennes).

2] soit, l'option n'est pas activée pour le partage SMB.
Pour cela, il faut se rendre dans Partages > Partages SMB > sélectionner le dataset concerné > cliquer sur les 3 points verticaux en bout de ligne > dans le menu déroulant, cliquer sur "Modifier" > cliquer sur le bouton "Options avancées" > paragraphe "Autres options" > cocher la case "Activer les clichés instantanés" > cliquer sur le bouton "Enregistrer".
Normalement, quel que soit l'option de paramètres prédéfinis choisi (champs "objectif"), la case "Activer les clichés instantanés" est cochée (activé) par défaut dans Truenas 13.
Si elle cette case est décochée, il y a donc de fortes chances que ce soit vous qui ayez désactivé cette option par le passé.

Si pour une raison ou pour une autre, vous souhaitez désactiver l'accès aux versions précédentes d'un fichier par l'explorateur de fichier, et que la case "Activer les clichés instantanés" est cochée et grisée. La case est verrouillée et n'est donc pas paramétrable en l'état.
Sur cette même page, il faudra modifier le champs "objectif" qui est sans doute défini sur "Default Share Parameters".
En effet, lors de la création du partage SMB, c'est l'option qui est sélectionné par défaut, qui défini un certains nombre de paramètres qui convient pour le besoin de la majorité d'entre-nous.
Il suffit de définir le champ "Objectif" sur "No presets" par exemple, et la case "Activer les clichés instantanés" sera déverrouillée. Vous pourrez, décocher la case pour désactiver l'accès aux versions précédentes depuis le navigateur de fichier. Pensez à enregistrer les modifications.
 
Top