LinuxFocus: Les droits d'accès des fichiers

Guido Socher

A propos de l'auteur : Il adore Linux car c'est un système libre et c'est aussi un plaisir de travailler avec des personnes de la communauté linux partout dans le monde. Il passe son temps libre avec sa petite amie, écoute la BBC World Service radio, pratique le cyclisme, et utilise avec plaisir Linux.

Écrire à l'auteur

Contents:
Les permissions de base des accès fichiers
T-bits, SUID and SGID

Les droits d'accès des fichiers

Résumé: Cet article est divise en deux partie:

La première partie (Les permissions de base des accès fichiers) est une petite introduction sur les concepts de base des permissions d'accès aux fichiers.

La deuxième partie (T-bit, SUID and SGID) couvre des fonctionnalités plus avancée de linux que les droits de base "read-write-execute" .

Les permissions de base des accès fichiers

Linux est un système mutli utilisateur qui permet de gérer différentes permissions d'accès aux fichiers. Chaque utilisateur a un identifiant, un nombre unique qui l'identifie. Les utilisateurs appartiennent également à un ou plusieurs groupes. Les groupes peuvent être employés pour limiter l'accès à un certain nombre de personnes. C'est un bon moyen pour rendre plus facile le travail avec un certain nombre de personnes en équipe. Pour vérifier votre identification de l'utilisateur et voir le groupe(s) auquel vous appartenez, tapez la commande ID:

>id
uid=550(alice) gid=100(users) groups=100(users),6(disk)

Les permissions d'accès pour un fichier peuvent être positionnés par propriétaire, groupe, et pour les autres sur la base de permissions en lecture (r), écriture (w) et éxecution (x). Vous pouvez utiliser la commande ls -l pour voir ces permissions.

>ls -l /usr/bin/id
-rwxr-xr-x 1 root root 8632 May 9 1998 /usr/bin/id

Le fichier /usr/bin/id appartient à l'utilisateur root et fait parti du groupe appelé root. Le

 -rwxr-xr-x

montre les permissions d'accès au fichier . Ce fichier a les droits en lecture , écriture ,et en exécution pour le propriétaire. Pour le groupe et les autres , ce fichier est lisible et exécutable.

Vous pouvez imaginer que les permissions sont un champ de bit avec 3 bits pour le propriétaire, le groupe, et les autres. Ce r-x correspond à 101 en binaire ou 4+1=5 en décimal. Le r-bits corresponds à la décimale 4 , le w_bit correspond à la décimale 2 et le x-bit correspond à la décimale 1.

sst
421
(nous verrons cela plus tard)

rwx
421
user
(proprietaire)

rwx
421
group

rwx
421
others

La commande chmod peut être utilisée pour changer les permissions. Pour des raisons de securité seulement le superutilisateur root ou le propriétaire du fichier peut changer les permissions. la commande chmod prend aussi bien en argument une représentation décimal qu'une représentation symbolique pour décrire les droit d'accès. La représentation symbolique est [ugoa][+-][rwx]. C'est l'une de ces lettres u (propriétaire du fichier ), g ( groupe ) , o ( les autres ), a ( tout le monde =u+g+o) suivi de + ou - permet d'ajouter ou de supprimer les permissions et la forme symbolique des permissions est de la forme r ( read = lecture ) w ( write l'écriture ) x ( exécution ). Pour donner au fichier "file.txt" les droits d'écriture pour tout le monde , tapez:

>chmod a+w   file.txt
or
>chmod 666   file.txt
>ls -l   file.txt
-rw-rw-rw-   1 alice   users   79 Jan 1 16:14 file.txt

chmod 644 file.txt positionnera les permissions "normal" avec pour le propriétaire lecture+écriture et seulement lecture pour tout le monde.

Changer de répertoire ( avec la commande cd ) est équivalent à exécuter le répertoire. Les permissions "Normal" pour le répertoire sont 755 et non 644:

>chmod 755   mydir
>ls -ld   mydir
drwxr-xr-x    2 alice    users    1024 Dec 31 22:32 mydir

Le umask défini les permissions par défaut . Les permissions par défaut sont mises lorsqu'un nouveau fichier ( ou répertoire ) est crée. Comme argument, cette commande prend une représentation décimale que vous n'êtes pas obligé de taper . Il peut prendre comme argument ces bits dans une représentation décimale que vous ne voulez pas avoir à mettre.

umask 022 est un bon choix. Avec les permissions 022 tout le monde peut lire, vos fichiers et "cd" dans vos répertoires mais c'est vous qui pouvez uniquement modifier les fichiers. Pour afficher la valeur du umask courant, tapez uniquement umask sans arguments.

Voici un exemple de l'utilisation de umask et chmod:

Le umask est mis aux bonnes valeurs standards
>umask
22

Prenez votre éditeur et créez le fichier appelle myscript:
>nedit myscript (or vi myscript ...)
Mettez le code suivant dedans:

#!/bin/sh
#myscript
echo -n "hello "
whoami
echo "Ce fichier file ( $0 ) avait les persmissions suivantes:"
ls -l $0 | cut -f1 -d" "

Sauvegardez le fichier script.
Maintenant il a les permissions 644 :
>ls -l myscript
-rw-r--r-- 1 alice users 108 Jan 1 myscript
Pour l'exécuter vous devez modifier ses droits d'accès:
>chmod 755 myscript
ou
>chmod a+x myscript
Maintenant éxecutez le:
>./myscript

Remarquez que le fichier script doit être lisible et exécutable alors que les binaires classiques ont seulement besoin d'être exécutables. Ceci est du au fait que le script doit être lu par un interpréteur ( l'interpréteur de commandes ). L'exécution du script devrait afficher:

 
hello alice
Ce fichier  ( ./myscript ) avais les permissions suivantes:
-rwxr-xr-x

T-bit, SUID and SGID

Apres avoir travaillé sous Linux depuis un certain moment , vous avez découvert probablement qu'il y a plus dans les droits d'accès aux fichiers que "rwx". Explorez un peu votre systeme de fichiers et vous allez voir des "s" et "t":

>ls -ld /usr/bin/crontab  /usr/bin/passwd  /usr/sbin/sendmail  /tmp

drwxrwxrwt 5 root root   1024 Jan 1 17:21 /tmp
-rwsr-xr-x 1 root root   0328 May 6 1998 /usr/bin/crontab
-r-sr-xr-x 1 root bin    5613 Apr 27 1998 /usr/bin/passwd
-rwsr-sr-x 1 root mail   89524 Dec 3 22:18 /usr/sbin/sendmail

Que veulent dire les bits "s" et "t"? Le champ de bit définissant les permissions d'accès a en réalité une longueur de 4 * 3 bits . Le chmod 755 est en fait un raccourci pour chmod 0755.

Le t-bit

Le t-bit (parfois appellé "sticky bit") est seulement utilisé avec les répertoires.Il est utilisé avec le répertoire /tmp comme vous pouvez le voir en haut.

Normalement ( sans le t-bit de positionné sur le répertoire ) les fichiers peuvent être effacés si le repertoire dans lequel ce trouve les fichiers possède les droits d'écriture pour la personne voulant effacer les fichiers. Ainsi si vous avez un répertoire ou n'importe qui peut venir mettre des fichier alors n'importe qui peut venir les effacer aussi.

Le t-bit change cette règle. Avec le t-bit positionné seul le propriétaire du fichier ou le propriétaire du répertoire a le droit d'effacer les fichiers. Le t-bit peut être positionné par la commande chmod a+tw ou 1777. Voici un exemple :

Alice crée un répertoire avec le t-bit de mis:
>mkdir mytmp
chmod 1777 mytmp

maintenant Bob met un fichier dedans:
>ls -al
drwxrwxrwt 3 alice users 1024 Jan 1 20:30 ./
-rw-r--r-- 1 bob users 0 Jan 1 20:31 f.txt

Ce fichier peut maintenant être effacé par Alice (propriétaire du répertoire) et Bob (le propriétaire du fichier) mais il ne peut être effacé par Tux:

>whoami
tux
rm -f f.txt
rm: f.txt: Opération interdite

S-bit positionné pour l'utilisateur

Les processus sous Linux s'éxecute avec l'identifiant de l'utilisateur (user-ID). Ceci leur donne accès aux ressources ( fichier etc ...) auquelles l'utilisateur a accès. L'identifiant effectif est celui qui détermine les accès aux fichiers. Sauvegardez le script suivant dans un fichier ayant pour nom idinfo et rendez le exécutable (chmod 755 idinfo).

#!/bin/sh
#idinfo: Afficher les informations sur l'utilisateur
echo " effective user-ID:"
id -un
echo " real user-ID:"
id -unr
echo " group ID:"
id -gn

Lorsque vous exécutez le script vous verrez que le processus qui tourne prend votre identifiant et l'identifiant de votre groupe:

 effective user-ID:
alice
 real user-ID:
alice
 group ID:
users

Quand Tux éxecute votre programme idinfo alors il a une sortie équivalente affichant que le processus tourne maintenant avec l'identifiant de Tux. La sortie du programme dépend uniquement de la personne qui exécute le programme et non pas du propriétaire de ce dernier.

Pour des raisons de sécurite le s-bit fonctionne uniquement pour des fichiers binaires ( code compile ) et non pas pour les scripts ( l'exception est les scripts perl ). Essayons de créer un programme C qui va apeller votre programme idinfo:

/*suidtest.c*/
#include <stdio.h>
#include <unistd.h>
int main(){
/*secure SUID programs MUST
*not trust any user input or environment variable!! */

char *env[]={"PATH=/bin:/usr/bin",NULL};
char prog[]="/home/alice/idinfo";
if (accès(prog,X_OK)){
fprintf(stderr,"ERROR: %s not executable\n",prog);
exit(1);
}
printf("running now %s ...\n",prog);
execle(prog,(const char*)NULL,env);
perror("suidtest");

return(1);
}

Compilez le programme avec "gcc -o suidtest -Wall suidtest.c" et et positionner le bit-s (SUID) de l'utilisateur:

>chmod 4755 suidtest
or
>chmod u+s suidtest

Executez le! Que se passe t-il? Executez le à partir d'un compte d'un autre utilisateur!

Le fichier suidtest appartient à alice et à le s-bit de positionné ou normalement il y a un x pour le propriétaire du fichier. Ceci fait que le fichier est éxecuté avec l'UID effectif de l'utilisateur qui possède le fichier au lieu de celui qui l'éxécute. Si Tux lance le programme alors cela devrait se passer comme ci-dessous:

>ls -l suidtest
-rwsr-xr-x 1 alice users 4741 Jan 1 21:53 suidtest
>whoami
tux

running now /home/alice/idinfo ...
effective user-ID:
alice
real user-ID:
tux
group ID:
users

Comme vous pouvez le voir c'est une fonctionnalité très puissante dans le cas ou root possède un fichier avec le s-bit positionné. N'importe quel utilisateur peut faire grace à ce fichier ce que normalement root est le seul à pouvoir réaliser. Quelques mots sur la sécurite. Quand vous écrivez un programme avec le s-bit, faites attention à ce que ce programme fasse uniquement ce que vous voulez. Implémentez toujours les chemins en dur dans le programme. Ne prennez pas en compte les variables ou fonctions se référençant aux variables d'environnements. Ne croyez jamais les donnée de l'utilisateur ( fichier de configuration , arguments de la ligne de commande....). Vérifiez les données des utilisateurs octet par octet pour savoir si elles sont valides.

Losque un programme SUID appartient a root alors l'utilisateur effectif et l'utilisateur reel peuvent être positionnés ( avec la fonctions setreuid() ).

Les programmes ayant le Set-UID sont souvent utilisés par "root"pour donner un accès aux utilisateurs classiques chose que seul "root" peut faire. Comme root vous pouvez modifier le suidtest.c pour permettre à n'importe quel utilisateur de lancer le script ppp-on/ppp-off sur votre machine.

S-bit positionné pour le group

Les fichiers éxecutables qui ont le s-bit de positionné sur le groupe, s'exécutent sous l'identifiant du groupe du propriétaire. C'est très proche de l'utilisation du s-bit pour l'utilisateur que nous avons vu dans le chapitre précédent.

Quand le bit-s est positionné pour le groupe d'un répertoire, alors le groupe est déterminé pour chaque fichier qui est créé dans ce répertoire. Alice appartient à 2 groupes:

>id
uid=550(alice) gid=100(users) groups=100(users),6(disk)

Normalement les fichiers sont créés pour elle avec le group "users". Mais si un répertoire est créé avec le group "disk" et que le bit-s du groupe est positionné, alors tous les fichiers qu'Alice crée on aussi l'identificateur de groupe (GID) "disk".

>chmod 2775 .
>ls -ld .
drwxrwsr-x 3 tux disk 1024 Jan 1 23:02 .

Si alice crée maintenant un nouveau fichier dans ce répertoire alors le groupe de ce fichier sera positionne à disk

>touch newfile
>ls -l newfile
-rw-r--r-- 1 alice disk 0 Jan 1 23:02 newfile

C'est un bon dispositif quand vous voulez travailler avec plusieurs personnes dans une équipe et vous assurer que le groupe IDs des dossiers est affecté au bon groupe pour le répertoire de travail de cette équipe, particulièrement dans un environnement où les utilisateurs ont normalement un umask 027 qui rend des dossiers inaccesibles pour des personnes en dehors du groupe.