Les Extended Attributes (xattr) et les ACL sous Linux

Post by **Hydraxx** » Wed May 27, 2026 6:30 pm

Les Extended Attributes (xattr) et les ACL sous Linux

Objectif du cours

Ce cours explique deux mécanismes importants de Linux :

Les attributs étendus, aussi appelés extended attributes ou xattr.
Les ACL, c'est-à-dire les Access Control Lists.

Ces deux notions sont liées à la gestion fine des métadonnées et des permissions sur les fichiers Linux.

L'idée centrale à retenir est simple :

Code: Select all

stat  = métadonnées classiques du fichier
xattr = métadonnées supplémentaires attachées au fichier
ACL   = permissions avancées, souvent stockées via les xattr

1. Rappel : les métadonnées classiques d'un fichier Linux

Sous Linux, un fichier n'est pas seulement un bloc de données. Il possède aussi des informations associées, stockées dans l'inode.

Ces informations sont les métadonnées classiques.

Exemples :

le numéro d'inode ;
la taille du fichier ;
le propriétaire ;
le groupe propriétaire ;
les permissions ;
les timestamps ;
le type du fichier ;
le nombre de liens physiques.

En C, ces informations sont récupérées avec :

Code: Select all

stat()
fstat()
lstat()

Exemple simple :

Code: Select all

#include <stdio.h>
#include <sys/stat.h>

int main(void)
{
    struct stat st;

    if (stat("test.txt", &st) == -1) {
        perror("stat");
        return 1;
    }

    printf("Taille : %ld octets\n", (long)st.st_size);
    printf("Inode  : %lu\n", (unsigned long)st.st_ino);
    printf("UID    : %u\n", st.st_uid);
    printf("GID    : %u\n", st.st_gid);

    return 0;
}

Important :

Code: Select all

struct stat

contient des champs fixes. On ne peut pas inventer dynamiquement un nouveau champ dans cette structure.

Par exemple, on ne peut pas ajouter :

Code: Select all

st_commentaire
st_signature
st_label_selinux

C'est justement pour cette raison que Linux utilise aussi un autre mécanisme : les extended attributes.

2. Les Extended Attributes : définition

Les extended attributes, ou xattr, sont des métadonnées supplémentaires attachées à un fichier.

Elles fonctionnent sous forme de paires :

Code: Select all

nom = valeur

Exemple :

Code: Select all

user.note = "fichier important"
user.author = "jean"
security.selinux = "system_u:object_r:httpd_sys_content_t:s0"

On peut donc voir un fichier comme ceci :

Code: Select all

inode
 ├── métadonnées classiques
 │    ├── taille
 │    ├── uid
 │    ├── gid
 │    ├── permissions
 │    └── timestamps
 │
 └── attributs étendus
      ├── user.note
      ├── user.author
      ├── security.selinux
      └── system.posix_acl_access

Les xattr sont donc des attributs complémentaires.

3. Différence entre stat et xattr

stat donne les métadonnées standard du fichier.

xattr permet d'ajouter des métadonnées supplémentaires.

Tableau récapitulatif :

Code: Select all

+----------------------+------------------------------+------------------------------+
| Élément              | stat                         | xattr                        |
+----------------------+------------------------------+------------------------------+
| Type                 | Métadonnées classiques       | Métadonnées étendues          |
| Structure            | Champs fixes                 | Nom = valeur                  |
| Exemple              | st_size, st_uid, st_mode     | user.note, security.selinux   |
| Dynamique            | Non                          | Oui                           |
| Attaché à l'inode    | Oui                          | Oui                           |
| Utilisé par sécurité | Partiellement                | Oui, très souvent             |
+----------------------+------------------------------+------------------------------+

À retenir :

Code: Select all

stat  = carte d'identité officielle du fichier
xattr = post-it supplémentaires attachés au fichier

4. Pourquoi Linux utilise les xattr ?

Les xattr servent à stocker des informations qui ne rentrent pas dans les métadonnées classiques.

Cas réels :

SELinux utilise des labels de sécurité.
Les capabilities Linux peuvent être stockées sur des exécutables.
Les ACL POSIX sont souvent stockées sous forme d'attributs étendus.
Des environnements graphiques peuvent stocker des tags ou commentaires.
Des outils de sauvegarde peuvent conserver des métadonnées spécifiques.
Des outils forensic peuvent inspecter ces métadonnées.

Exemples importants :

Code: Select all

security.selinux
security.capability
system.posix_acl_access
system.posix_acl_default

5. Les namespaces des xattr

Les noms des xattr sont organisés en namespaces.

Les principaux sont :

Code: Select all

user.*
security.*
system.*
trusted.*

5.1. user.*

Le namespace user.* est destiné aux attributs définis par les utilisateurs.

Exemples :

Code: Select all

user.note
user.author
user.comment
user.tag

Exemple :

Code: Select all

user.note = "cours linux"

5.2. security.*

Le namespace security.* est utilisé par les mécanismes de sécurité.

Exemples :

Code: Select all

security.selinux
security.capability

security.selinux peut contenir le label SELinux d'un fichier.

security.capability peut contenir les capabilities données à un binaire.

5.3. system.*

Le namespace system.* est utilisé par le noyau et le système de fichiers.

Exemples :

Code: Select all

system.posix_acl_access
system.posix_acl_default

Ces attributs peuvent contenir les ACL POSIX.

5.4. trusted.*

Le namespace trusted.* est réservé à des usages privilégiés.

En général, il faut des droits élevés pour le manipuler.

6. Commandes shell pour les xattr

Deux commandes principales :

Code: Select all

getfattr
setfattr

6.1. Ajouter un attribut

Code: Select all

touch fichier.txt
setfattr -n user.note -v "fichier important" fichier.txt

Ici :

-n indique le nom de l'attribut.
-v indique la valeur.
fichier.txt est le fichier cible.

6.2. Lire les attributs

Code: Select all

getfattr -d fichier.txt

Sortie possible :

Code: Select all

# file: fichier.txt
user.note="fichier important"

6.3. Supprimer un attribut

Code: Select all

setfattr -x user.note fichier.txt

7. APIs Linux des xattr

Les APIs principales sont :

Code: Select all

setxattr()
getxattr()
listxattr()
removexattr()

Il existe trois familles :

Code: Select all

setxattr()      travaille avec un chemin
fsetxattr()     travaille avec un descripteur de fichier
lsetxattr()     travaille avec un chemin sans suivre les liens symboliques

Même logique pour :

Code: Select all

getxattr() / fgetxattr() / lgetxattr()
listxattr() / flistxattr() / llistxattr()
removexattr() / fremovexattr() / lremovexattr()

7.1. setxattr

Prototype simplifié :

Code: Select all

int setxattr(const char *path,
             const char *name,
             const void *value,
             size_t size,
             int flags);

Rôle :

Code: Select all

Ajouter ou modifier un attribut étendu sur un fichier.

Paramètres :

path : chemin du fichier.
name : nom de l'attribut.
value : valeur à écrire.
size : taille de la valeur.
flags : comportement spécial.

7.2. getxattr

Prototype simplifié :

Code: Select all

ssize_t getxattr(const char *path,
                 const char *name,
                 void *value,
                 size_t size);

Rôle :

Code: Select all

Lire la valeur d'un attribut étendu.

7.3. listxattr

Prototype simplifié :

Code: Select all

ssize_t listxattr(const char *path,
                  char *list,
                  size_t size);

Rôle :

Code: Select all

Lister les noms des attributs étendus d'un fichier.

7.4. removexattr

Prototype simplifié :

Code: Select all

int removexattr(const char *path,
                const char *name);

Rôle :

Code: Select all

Supprimer un attribut étendu.

8. Flags importants : XATTR_CREATE et XATTR_REPLACE

Deux flags importants :

Code: Select all

XATTR_CREATE
XATTR_REPLACE

8.1. XATTR_CREATE

Code: Select all

XATTR_CREATE

signifie :

Code: Select all

Créer l'attribut uniquement s'il n'existe pas déjà.

Si l'attribut existe déjà, l'appel échoue.

8.2. XATTR_REPLACE

Code: Select all

XATTR_REPLACE

signifie :

Code: Select all

Remplacer l'attribut uniquement s'il existe déjà.

Si l'attribut n'existe pas, l'appel échoue.

8.3. Pourquoi c'est utile ?

Ces flags évitent certaines erreurs logiques.

Exemples :

éviter d'écraser une valeur déjà existante ;
forcer la modification uniquement si l'attribut existe ;
avoir un comportement plus strict ;
réduire certains risques de race condition logique.

9. Pattern Linux classique : demander la taille, allouer, relire

Beaucoup d'APIs Linux fonctionnent ainsi :

Code: Select all

1. Appeler une fonction avec buffer = NULL et size = 0
2. Récupérer la taille nécessaire
3. Allouer un buffer avec malloc()
4. Appeler à nouveau la fonction pour récupérer les données

Exemple avec getxattr :

Code: Select all

ssize_t size = getxattr("fichier.txt", "user.note", NULL, 0);

Ici, on ne lit pas encore la valeur. On demande juste la taille nécessaire.

Ensuite :

Code: Select all

char *buffer = malloc(size + 1);

Puis :

Code: Select all

getxattr("fichier.txt", "user.note", buffer, size);

C'est un pattern très important en programmation système Linux.

10. Programme complet xattr en C

Ce programme montre :

création d'un fichier ;
ajout d'un xattr ;
lecture du xattr ;
listing des xattr ;
modification avec XATTR_REPLACE ;
suppression du xattr.

Code: Select all

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/xattr.h>
#include <errno.h>

int main(void)
{
    const char *path = "test_xattr.txt";
    const char *attr_name = "user.note";
    const char *attr_value = "Fichier important pour comprendre les xattr";

    /*
        open() crée ou ouvre le fichier.

        O_CREAT  : crée le fichier s'il n'existe pas.
        O_RDWR   : ouvre en lecture/écriture.
        O_TRUNC  : vide le fichier s'il existe déjà.
        0644     : permissions classiques du fichier.
    */
    int fd = open(path, O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    /*
        On écrit un contenu normal dans le fichier.

        Important :
        le contenu du fichier et les xattr sont deux choses différentes.
    */
    if (write(fd, "Hello\n", 6) == -1) {
        perror("write");
        close(fd);
        return 1;
    }

    /*
        fsetxattr() ajoute un attribut étendu via un file descriptor.

        fd         : fichier cible déjà ouvert.
        attr_name  : nom de l'attribut.
        attr_value : valeur à écrire.
        strlen()   : taille de la valeur.
        XATTR_CREATE : échoue si l'attribut existe déjà.
    */
    if (fsetxattr(fd,
                  attr_name,
                  attr_value,
                  strlen(attr_value),
                  XATTR_CREATE) == -1) {
        perror("fsetxattr");
        close(fd);
        return 1;
    }

    /*
        Première lecture :
        on demande seulement la taille nécessaire.

        value = NULL
        size  = 0

        fgetxattr() retourne la taille de la valeur.
    */
    ssize_t size = fgetxattr(fd, attr_name, NULL, 0);
    if (size == -1) {
        perror("fgetxattr size");
        close(fd);
        return 1;
    }

    /*
        On alloue un buffer assez grand.

        +1 est utile si on veut afficher la valeur comme une chaîne C.
    */
    char *buffer = malloc(size + 1);
    if (buffer == NULL) {
        perror("malloc");
        close(fd);
        return 1;
    }

    /*
        Deuxième lecture :
        on récupère réellement la valeur.
    */
    ssize_t ret = fgetxattr(fd, attr_name, buffer, size);
    if (ret == -1) {
        perror("fgetxattr value");
        free(buffer);
        close(fd);
        return 1;
    }

    /*
        Les xattr ne sont pas forcément des chaînes C.
        Ici, notre valeur est du texte, donc on ajoute un '\0'.
    */
    buffer[size] = '\0';

    printf("Attribut lu : %s = %s\n", attr_name, buffer);

    free(buffer);

    /*
        Maintenant, on liste les noms des xattr.

        Même pattern :
        - premier appel pour la taille
        - malloc
        - deuxième appel pour récupérer la liste
    */
    ssize_t list_size = flistxattr(fd, NULL, 0);
    if (list_size == -1) {
        perror("flistxattr size");
        close(fd);
        return 1;
    }

    char *list = malloc(list_size);
    if (list == NULL) {
        perror("malloc list");
        close(fd);
        return 1;
    }

    list_size = flistxattr(fd, list, list_size);
    if (list_size == -1) {
        perror("flistxattr list");
        free(list);
        close(fd);
        return 1;
    }

    printf("\nListe des attributs :\n");

    /*
        La liste retournée par flistxattr() est une suite de chaînes C :

        user.note\0user.test\0...

        Il faut donc avancer de strlen(nom) + 1 à chaque tour.
    */
    for (ssize_t i = 0; i < list_size; ) {
        printf("- %s\n", &list[i]);
        i += strlen(&list[i]) + 1;
    }

    free(list);

    /*
        Modification de l'attribut.

        XATTR_REPLACE signifie :
        remplacer uniquement si l'attribut existe déjà.
    */
    const char *new_value = "Nouvelle valeur";

    if (fsetxattr(fd,
                  attr_name,
                  new_value,
                  strlen(new_value),
                  XATTR_REPLACE) == -1) {
        perror("fsetxattr replace");
        close(fd);
        return 1;
    }

    printf("\nAttribut modifié avec XATTR_REPLACE.\n");

    /*
        Suppression de l'attribut étendu.
    */
    if (fremovexattr(fd, attr_name) == -1) {
        perror("fremovexattr");
        close(fd);
        return 1;
    }

    printf("Attribut supprimé.\n");

    close(fd);
    return 0;
}

Compilation :

Code: Select all

gcc xattr_demo.c -o xattr_demo

Exécution :

Code: Select all

./xattr_demo

11. Ce qu'il faut retenir sur les xattr

À retenir absolument :

Code: Select all

setxattr     écrire un attribut étendu
getxattr     lire un attribut étendu
listxattr    lister les noms des attributs
removexattr  supprimer un attribut

Les variantes importantes :

Code: Select all

f* = travaille avec un file descriptor
l* = ne suit pas les liens symboliques

Concept fondamental :

Code: Select all

xattr = métadonnée supplémentaire attachée à l'inode

12. Introduction aux ACL

ACL signifie :

Code: Select all

Access Control List

Une ACL est une liste de permissions plus détaillée que les permissions UNIX classiques.

Le modèle UNIX classique repose sur :

Code: Select all

owner / group / other

Exemple :

Code: Select all

-rwxr-x---

Cela signifie :

Code: Select all

owner : rwx
group : r-x
other : ---

Le problème est que ce modèle est limité.

On ne peut pas facilement dire :

Code: Select all

jean  : rw-
paul  : r--
alice : rwx
groupe_admin : rwx
groupe_dev   : r--

Pour cela, on utilise les ACL.

13. Problème des permissions UNIX classiques

Avec chmod, on peut faire :

Code: Select all

chmod 750 fichier

Ce qui donne :

Code: Select all

owner : rwx
group : r-x
other : ---

Mais imaginons :

le propriétaire doit avoir rwx ;
le groupe principal doit avoir r--;
un utilisateur précis doit avoir rw- ;
un autre utilisateur doit avoir r--;
un groupe supplémentaire doit avoir rwx.

Le modèle classique ne suffit plus.

Les ACL permettent d'ajouter ces règles spécifiques.

14. Structure logique d'une ACL

Une ACL est une liste d'entrées.

Chaque entrée contient généralement :

Code: Select all

type + identifiant éventuel + permissions

Exemple :

Code: Select all

user:paul:rw-

Ici :

Code: Select all

type        = user
identifiant = paul
permissions = rw-

Autre exemple :

Code: Select all

group:dev:r-x

Ici :

Code: Select all

type        = group
identifiant = dev
permissions = r-x

15. Entrées ACL importantes

Les entrées importantes à connaître sont :

Code: Select all

ACL_USER_OBJ
ACL_USER
ACL_GROUP_OBJ
ACL_GROUP
ACL_MASK
ACL_OTHER

15.1. ACL_USER_OBJ

Représente le propriétaire classique du fichier.

Dans getfacl, cela apparaît comme :

Code: Select all

user::rw-

Le double deux-points signifie :

Code: Select all

utilisateur propriétaire, pas un utilisateur nommé spécifique

15.2. ACL_USER

Représente un utilisateur spécifique.

Exemple :

Code: Select all

user:paul:rwx

Ici, l'utilisateur paul a les permissions rwx.

15.3. ACL_GROUP_OBJ

Représente le groupe propriétaire classique du fichier.

Dans getfacl :

Code: Select all

group::r--

15.4. ACL_GROUP

Représente un groupe spécifique.

Exemple :

Code: Select all

group:dev:r-x

15.5. ACL_OTHER

Représente les autres utilisateurs.

Dans getfacl :

Code: Select all

other::---

15.6. ACL_MASK

Le mask est un point très important.

Il agit comme un plafond de permissions.

Il limite les permissions effectives de certaines entrées ACL.

Exemple :

Code: Select all

user:paul:rwx
mask::r--

Même si paul a théoriquement rwx, le mask limite ses droits effectifs à :

Code: Select all

r--

On peut le voir comme un AND logique :

Code: Select all

permissions demandées : rwx
mask                 : r--
résultat effectif    : r--

À retenir :

Code: Select all

ACL_MASK = plafond des permissions pour les entrées ACL nommées et les groupes

16. getfacl : afficher les ACL

La commande principale pour lire les ACL est :

Code: Select all

getfacl

Exemple :

Code: Select all

getfacl fichier.txt

Sortie possible :

Code: Select all

# file: fichier.txt
# owner: jean
# group: users
user::rw-
user:paul:rwx
group::r--
mask::rwx
other::---

Explication :

Code: Select all

user::rw-       propriétaire du fichier
user:paul:rwx   utilisateur paul
group::r--      groupe propriétaire
mask::rwx       mask ACL
other::---      autres utilisateurs

Quand un fichier possède des ACL, ls -l peut afficher un + :

Code: Select all

-rw-rwx---+ 1 jean users 12 mai 27 20:00 fichier.txt

Le + signifie :

Code: Select all

ce fichier possède des ACL étendues

17. setfacl : modifier les ACL

La commande principale pour modifier les ACL est :

Code: Select all

setfacl

17.1. Ajouter une ACL utilisateur

Code: Select all

setfacl -m u:paul:rwx fichier.txt

Signification :

Code: Select all

u:paul:rwx

veut dire :

Code: Select all

donner rwx à l'utilisateur paul

17.2. Ajouter une ACL groupe

Code: Select all

setfacl -m g:dev:r-x fichier.txt

Signification :

Code: Select all

donner r-x au groupe dev

17.3. Supprimer une entrée ACL

Code: Select all

setfacl -x u:paul fichier.txt

Supprime l'entrée ACL de l'utilisateur paul.

17.4. Supprimer toutes les ACL étendues

Code: Select all

setfacl -b fichier.txt

Supprime les ACL étendues et revient à un modèle plus classique.

18. Default ACL

Les default ACL concernent les dossiers.

Elles permettent de définir des permissions héritées automatiquement par les nouveaux fichiers créés dans un dossier.

Exemple :

Code: Select all

mkdir projet
setfacl -d -m g:dev:rwx projet

Ici :

Code: Select all

-d

signifie :

Code: Select all

default ACL

Cela veut dire :

Code: Select all

les nouveaux fichiers créés dans projet hériteront d'une ACL pour le groupe dev

C'est très utilisé pour :

dossiers partagés ;
serveurs ;
environnements multi-utilisateurs ;
Samba ;
NFS ;
projets d'entreprise.

19. Relation entre ACL et xattr

Point fondamental :

Code: Select all

Les ACL Linux sont souvent stockées dans les extended attributes.

Exemples :

Code: Select all

system.posix_acl_access
system.posix_acl_default

Cela signifie :

Code: Select all

xattr = mécanisme générique de métadonnées
ACL   = système de permissions avancées construit dessus

On peut résumer ainsi :

Code: Select all

inode
 ├── stat
 │    ├── uid
 │    ├── gid
 │    ├── mode
 │    └── timestamps
 │
 └── xattr
      ├── system.posix_acl_access
      ├── system.posix_acl_default
      ├── security.selinux
      └── security.capability

20. APIs ACL en C

Les ACL peuvent être manipulées en C avec la libacl.

Les fonctions importantes sont :

Code: Select all

acl_get_file()
acl_set_file()
acl_get_entry()
acl_get_permset()
acl_add_perm()
acl_free()

Mais pour ton niveau actuel, il n'est pas nécessaire de mémoriser toute la lib ACL en profondeur.

Il faut surtout connaître :

Code: Select all

getfacl
setfacl
ACL_USER
ACL_GROUP
ACL_MASK
default ACL
relation ACL/xattr

20.1. Exemple minimal : lire une ACL en C

Code: Select all

#include <stdio.h>
#include <sys/types.h>
#include <sys/acl.h>

int main(void)
{
    acl_t acl;

    /*
        acl_get_file() récupère l'ACL d'accès du fichier.

        ACL_TYPE_ACCESS signifie :
        on veut l'ACL qui contrôle l'accès normal au fichier.
    */
    acl = acl_get_file("fichier.txt", ACL_TYPE_ACCESS);
    if (acl == NULL) {
        perror("acl_get_file");
        return 1;
    }

    /*
        acl_to_text() convertit l'ACL en texte lisible.
        C'est pratique pour l'affichage.
    */
    ssize_t len;
    char *text = acl_to_text(acl, &len);
    if (text == NULL) {
        perror("acl_to_text");
        acl_free(acl);
        return 1;
    }

    printf("%s\n", text);

    /*
        Les objets retournés par la libacl doivent être libérés avec acl_free().
    */
    acl_free(text);
    acl_free(acl);

    return 0;
}

Compilation :

Code: Select all

gcc acl_read.c -o acl_read -lacl

21. Exemple pratique complet : xattr + ACL en shell

On crée un fichier :

Code: Select all

touch demo.txt

On ajoute un xattr :

Code: Select all

setfattr -n user.note -v "cours linux" demo.txt

On lit les xattr :

Code: Select all

getfattr -d demo.txt

On ajoute une ACL :

Code: Select all

setfacl -m u:paul:r-- demo.txt

On lit les ACL :

Code: Select all

getfacl demo.txt

On peut vérifier avec ls :

Code: Select all

ls -l demo.txt

Sortie possible :

Code: Select all

-rw-r--r--+ 1 jean users 0 mai 27 20:00 demo.txt

Le + indique la présence d'une ACL.

22. Différences fondamentales à retenir

22.1. stat vs xattr

Code: Select all

stat  = métadonnées classiques
xattr = métadonnées complémentaires

22.2. permissions UNIX vs ACL

Code: Select all

permissions UNIX = owner / group / other
ACL              = permissions détaillées par utilisateur ou groupe

22.3. xattr vs ACL

Code: Select all

xattr = mécanisme générique nom/valeur
ACL   = système de permissions avancées pouvant être stocké via xattr

23. Cas réels d'utilisation

23.1. SELinux

SELinux utilise des labels de sécurité.

Exemple :

Code: Select all

security.selinux

Ces labels permettent au système de décider si un processus peut accéder à un fichier selon une politique de sécurité.

23.2. Capabilities

Les capabilities permettent de donner à un programme certains privilèges précis sans lui donner tout le pouvoir de root.

Exemple :

Code: Select all

security.capability

23.3. ACL sur serveur

Sur un serveur multi-utilisateurs, on peut donner des droits différents à plusieurs utilisateurs sans créer une organisation compliquée de groupes.

Exemple :

Code: Select all

setfacl -m u:alice:rw- rapport.txt
setfacl -m u:bob:r-- rapport.txt
setfacl -m g:admin:rwx rapport.txt

23.4. Forensic

En analyse forensic, il est utile de vérifier :

les xattr suspects ;
les capabilities inhabituelles ;
les ACL trop permissives ;
les labels SELinux modifiés.

Commandes utiles :

Code: Select all

getfattr -d fichier
getfacl fichier
getcap fichier
ls -l
stat fichier

24. Ce qu'il faut retenir pour la programmation système

Pour ton niveau actuel, retiens surtout :

24.1. xattr

À connaître en API :

Code: Select all

setxattr()
getxattr()
listxattr()
removexattr()

Variantes :

Code: Select all

f* = file descriptor
l* = lien symbolique non suivi

Pattern important :

Code: Select all

size = getxattr(..., NULL, 0);
buffer = malloc(size);
getxattr(..., buffer, size);

24.2. ACL

À connaître surtout en concept :

Code: Select all

ACL = permissions avancées
getfacl = lire les ACL
setfacl = modifier les ACL
ACL_MASK = plafond de permissions
default ACL = héritage sur les dossiers

Les APIs ACL C existent, mais elles sont moins prioritaires à mémoriser maintenant que les APIs xattr.

25. Pièges fréquents

25.1. Croire que ls -l montre tout

Code: Select all

ls -l

ne montre pas forcément toutes les permissions réelles si des ACL sont présentes.

Il faut utiliser :

Code: Select all

getfacl

25.2. Oublier le mask ACL

Une entrée peut afficher :

Code: Select all

user:paul:rwx

mais si le mask est :

Code: Select all

mask::r--

les permissions effectives de paul peuvent être limitées.

25.3. Penser que les xattr sont forcément du texte

Un xattr peut contenir des données binaires.

Donc quand on lit un xattr en C, il ne faut pas toujours supposer qu'il s'agit d'une chaîne C.

25.4. Oublier les variantes f*

Quand on travaille déjà avec un fichier ouvert, les fonctions f* sont souvent plus propres :

Code: Select all

fgetxattr()
fsetxattr()
flistxattr()
fremovexattr()

25.5. Oublier les liens symboliques

Les fonctions l* ne suivent pas les liens symboliques.

C'est important en sécurité.

Exemple :

Code: Select all

lgetxattr()
lsetxattr()
llistxattr()
lremovexattr()

26. Résumé final

À retenir :

Code: Select all

stat
 └── métadonnées classiques du fichier

xattr
 └── métadonnées étendues nom = valeur

ACL
 └── permissions avancées par utilisateur/groupe

Les xattr permettent d'attacher des informations supplémentaires à l'inode.

Les ACL permettent de dépasser le modèle classique :

Code: Select all

owner / group / other

Le lien fondamental :

Code: Select all

Les ACL Linux peuvent être stockées dans les xattr.

Exemples importants :

Code: Select all

system.posix_acl_access
system.posix_acl_default
security.selinux
security.capability

APIs xattr à retenir :

Code: Select all

setxattr
getxattr
listxattr
removexattr

Commandes ACL à retenir :

Code: Select all

getfacl
setfacl

Vision globale :

Code: Select all

Linux moderne ne se limite pas aux permissions rwx classiques.
Il utilise aussi des métadonnées étendues et des systèmes de permissions plus fins.

27. Mini fiche mémoire

Code: Select all

stat()
    Lire les métadonnées classiques.

setxattr()
    Ajouter ou modifier un attribut étendu.

getxattr()
    Lire un attribut étendu.

listxattr()
    Lister les attributs étendus.

removexattr()
    Supprimer un attribut étendu.

getfattr
    Commande shell pour lire les xattr.

setfattr
    Commande shell pour écrire/supprimer les xattr.

getfacl
    Commande shell pour afficher les ACL.

setfacl
    Commande shell pour modifier les ACL.

ACL_MASK
    Plafond de permissions effectives.

Default ACL
    ACL héritée automatiquement dans un dossier.

system.posix_acl_access
    xattr contenant l'ACL d'accès.

system.posix_acl_default
    xattr contenant l'ACL par défaut d'un dossier.

Inside The System - Développement système Windows

Les Extended Attributes (xattr) et les ACL sous Linux

Les Extended Attributes (xattr) et les ACL sous Linux

Who is online