credentials - Identifiants de processus
Chaque processus a un identifiant unique entier positif qui lui est
attribué à sa création (avec
fork(2)). Un
processus peut connaître son PID avec
getpid(2). Un PID est
représenté par le type
pid_t (défini dans
<sys/types.h>).
Les PID sont utilisés dans un certain nombre d'appels système pour
identifier le processus affecté, par exemple :
kill(2),
ptrace(2),
setpriority(2),
setpgid(2),
setsid(2),
sigqueue(3) et
waitpid(2).
Le PID d'un processus est conservé au travers d'un
execve(2).
L'identifiant de processus parent d'un processus identifie le processus qui l'a
créé avec
fork(2). Un processus peut connaître son
PPID avec
getppid(2). Un PPID est représenté à
l'aide du type
pid_t.
Le PPID d'un processus est conservé au travers d'un
execve(2).
Chaque processus a un identifiant de session et un identifiant de groupe de
processus, tous deux représentés par le type
pid_t. Un
processus peut connaître son identifiant de session avec
getsid(2) et son identifiant de groupe de processus avec
getpgrp(2).
Un processus enfant créé par
fork(2) hérite de
l'identifiant de session et de l'identifiant de groupe de processus de son
parent. Les identifiants de session et de groupe de processus sont
préservés au travers d'un
execve(2).
Les sessions et les groupes de processus sont des abstractions destinées
à aider au contrôle des tâches dans le shell. Un groupe
de processus (parfois appelé
« tâche ») est un ensemble de processus
ayant le même identifiant de groupe de processus ; le shell
crée un nouveau groupe de processus pour le(s) processus
utilisé(s) pour exécuter une commande unique ou pipeline (par
exemple, les deux processus créés pour exécuter la
commande « ls | wc » sont
placés dans le même groupe de processus). L'appartenance
à un groupe de processus peut être changée avec
setpgid(2). Le processus dont le PID est égal à son
identifiant de groupe de processus est le
leader du groupe de
processus.
Une session est un ensemble de processus ayant le même identifiant de
session. Tous les membres d'un groupe de processus ont également le
même identifiant de session (tous les membres d'un groupe de processus
appartiennent à la même session, donc les sessions et les
groupes de processus forment une hiérarchie stricte à deux
niveaux). Une nouvelle session est créée lorsqu'un processus
appelle
setsid(2) qui crée une nouvelle session dont
l'identifiant est le PID de ce processus. Le créateur de cette session
est appelé
leader de session.
Tous les processus d'une session partagent un
terminal de
contrôle. Le terminal de contrôle est créé
lorsque le leader de session ouvre un terminal pour la première fois
(sauf si le paramètre
O_NOCTTY est précisé lors de
l'appel de
open(2)). Un terminal ne peut être le terminal de
contrôle que d'une seule session.
Il ne peut y avoir plus d'une tâche ayant la place de
« tâche de premier plan » ; les
autres tâches de la sessions sont des « tâches
d'arrière plan ». Seule la tâche de premier plan
peut recevoir des informations depuis le terminal ; si un job
d'arrière plan tente de recevoir des informations du terminal, le
signal
SIGTTIN est renvoyé au groupe du processus, ce qui a pour
effet de suspendre la tâche. Si le terminal a reçu l'attribut
TOSTOP (consultez
termios(3)), alors seule la tâche de
premier plan est autorisée à afficher des données dans le
terminal ; l'envoi de données de tâches d'arrière
plan vers le terminal déclenche un signal
SIGTTOU, ce qui a pour
effet de suspendre la tâche. Lorsqu'une touche du clavier qui
génère un signal est enfoncée (par exemple, la touche
interrupt qui provoque normalement un Contrôle-C), le signal est
envoyé au processus de premier plan.
Divers appels système et fonctions de bibliothèque peuvent agir
sur tous les membres d'un groupe de processus, notamment
kill(2),
killpg(2),
getpriority(2),
setpriority(2),
ioprio_get(2),
ioprio_set(2),
waitid(2) et
waitpid(2). Consultez également la discussion au sujet des
opérations
F_GETOWN,
F_GETOWN_EX,
F_SETOWN et
F_SETOWN_EX dans
fcntl(2).
Chaque processus a un certain nombre d'identifiants d'utilisateur et de groupe.
Ces identifiants sont des entiers représentés respectivement
avec les types
uid_t et
gid_t (définis dans
<sys/types.h>).
Sous Linux, chaque processus a les identifiants d'utilisateur et de groupe
suivants :
- •
- Identifiant d'utilisateur réel et identifiant de
groupe réel. Ces identifiants déterminent le
propriétaire du processus. Un processus peut déterminer ses
UID et GID réels avec getuid(2) et getgid(2).
- •
- UID effectif et GID effectif. Ces identifiants sont
utilisés par le noyau pour déterminer les permissions de ce
processus lors d'accès à des ressources partagées
telles que les files de messages, la mémoire partagée ou les
sémaphores. Sur la plupart des systèmes UNIX, ces
identifiants déterminent aussi les permissions d'accès aux
fichiers. Cependant, Linux utilise l'identifiant d'utilisateur du
système de fichiers (décrit plus bas) pour cette
tâche. Un processus peut déterminer son UID (GID) effectif
avec geteuid(2) (getegid(2)).
- •
- UID sauvegardé et GID sauvegardé. Ces
identifiants sont utilisés dans les programmes set-user-ID et
set-group-ID pour sauvegarder une copie des identifiants effectifs
correspondants lors de l'exécution du programme (consultez
execve(2)). Un programme set-user-ID peut prendre et abandonner des
privilèges en changeant son UID effectif entre les valeurs de ses
UID réel et sauvegardé. Cet échange est
réalisé par les appels système seteuid(2),
setreuid(2) ou setresuid(2). Un programme set-group-ID peut
effectuer les opérations correspondantes avec setegid(2),
setregid(2) ou setresgid(2). Un processus peut obtenir son
UID sauvegardé avec getresuid(2) et son GID
sauvegardé avec getresgid(2)).
- •
- UID et GID du système de fichiers
(spécifiques à Linux). Ces identifiants, ainsi que les
identifiants de groupe additionnels décrits plus bas, sont
utilisés pour déterminer les permissions d'accès aux
fichiers ; consultez path_resolution(7) pour plus de
détails. Lorsque l'UID (ou GID) effectif d'un processus est
modifié, le noyau définit automatiquement l'UID (ou GID) du
système de fichiers à la même valeur. Ainsi, les
identifiants du système de fichiers sont en général
égaux aux identifiants effectifs, et la sémantique des
vérifications de permissions sont les mêmes sous Linux et
sous les autres UNIX. Les identifiants du système de fichiers
peuvent prendre une valeur différente des identifiants effectifs en
utilisant les appels setfsuid(2) et setfsgid(2).
- •
- GID additionnels. Il s'agit d'un ensemble d'identifiants de
groupe supplémentaires qui sont utilisés pour les
vérifications de permissions d'accès aux fichiers et autres
ressources partagées. Avant Linux 2.6.4, un processus
pouvait avoir jusqu'à 32 groupes additionnels ;
depuis Linux 2.6.4, cette limite est de 65536 groupes
additionnels. L'appel sysconf(_SC_NGROUPS_MAX) peut être
utilisé pour déterminer le nombre de groupes additionnels
auxquels un processus peut appartenir. Un processus peut consulter son
ensemble de GID additionnels avec getgroups(2).
Un processus enfant créé par
fork(2) hérite des
copies des UID et GID de son parent. Lors d'un
execve(2), les UID et
GID réels ainsi que les GID supplémentaires sont
préservés ; les identifiants effectifs et
sauvegardés peuvent être modifiés comme indiqué
dans
execve(2).
En dehors des contextes décrits ci‐dessus, les UID d'un processus
sont également utilisés dans les cas suivants :
- •
- lors de la vérification des permissions pour l'envoi
de signaux (consultez kill(2)) ;
- •
- lors de la vérification des permissions pour la
modification des paramètres d'ordonnancement (politesse, politique
et priorité d'ordonnancement temps‐réel,
priorité d'E/S) avec setpriority(2),
sched_setaffinity(2), sched_setscheduler(2),
sched_setparam(2), sched_setattr(2) et
ioprio_set(2) ;
- •
- lors de la vérification de limites de ressources
(consultez getrlimit(2)) ;
- •
- lorsque la limite du nombre d'instances inotify que le
processus peut créer est vérifiée (consultez
inotify(7)).
Soumis aux règles décrites dans les pages de manuel
concernées, un processus peut se servir des API suivantes pour modifier
ses UID et GID.
-
setuid(2) (setgid(2))
- Modifier l'UID (ou le GID) réel (et
éventuellement effectif et sauvegardé) d'un processus.
-
seteuid(2) (setegid(2))
- Modifier l'UID (ou le GID) effectif d'un processus.
-
setfsuid(2) (setfsgid(2))
- Modifier l'UID (ou le GID) du système de fichiers
d'un processus.
-
setreuid(2) (setregid(2))
- Modifier les UID (ou le GID) réel et effectif (et
éventuellement sauvegardé) d'un processus.
-
setresuid(2) (setresgid(2))
- Modifier les UID (ou le GID) réel, effectif et
sauvegardé d'un processus.
-
setgroups(2)
- Modifier la liste des groupes additionnels d'un
processus
Toutes les modifications d'UID (ou de GID) effectif d'un processus sont
automatiquement propagées sur l'UID (ou le GID) du système de
fichiers du processus. Les modifications d'UID (ou de GID) effectif d'un
processus peuvent aussi affecter l'attribut
« dumpable » du processus, comme décrit
dans
prctl(2).
Les modifications d'UID (ou de GID) d'un processus peuvent affecter les
capacités du processus, comme décrit dans
capabilities(7).
Les PID, PPID, PGID et SID sont spécifiés dans POSIX.1-2001. Les
identifiants réels, effectifs et sauvegardés, et les
identifiants de groupe additionnels sont spécifiés dans
POSIX.1-2001. Les UID et GID du système de fichiers sont une extension
de Linux.
Plusieurs champs du fichier
/proc/pid
/status montrent les
identifiants du processus décrits ci‐dessus. Consultez
proc(5) pour plus d'informations.
La spécification POSIX des threads demande que les identifiants soient
partagés par tous les threads d'un processus. Toutefois, au niveau du
noyau, Linux maintient des identifiants d'utilisateurs et de groupes
séparés pour chaque thread. L'implémentation des threads
NPTL effectue un certain travail pour s'assurer que toute modification
d'identifiants d'utilisateur ou de groupe (par exemple, au moyen d'appels
à
setuid(2) ou
setresuid(2)) soit propagée vers
tous les threads POSIX d'un processus. Consultez
nptl(7) pour plus de
détails.
bash(1),
csh(1),
groups(1),
id(1),
newgrp(1),
ps(1),
runuser(1),
setpriv(1),
sg(1),
su(1),
access(2),
execve(2),
faccessat(2),
fork(2),
getgroups(2),
getpgrp(2),
getpid(2),
getppid(2),
getsid(2),
kill(2),
setegid(2),
seteuid(2),
setfsgid(2),
setfsuid(2),
setgid(2),
setgroups(2),
setpgid(2),
setresgid(2),
setresuid(2),
setsid(2),
setuid(2),
waitpid(2),
euidaccess(3),
initgroups(3),
killpg(3),
tcgetpgrp(3),
tcgetsid(3),
tcsetpgrp(3),
group(5),
passwd(5),
shadow(5),
capabilities(7),
namespaces(7),
path_resolution(7),
pid_namespaces(7),
pthreads(7),
signal(7),
system_data_types(7),
unix(7),
user_namespaces(7),
sudo(8)
La traduction française de cette page de manuel a été
créée par Christophe Blaess
<
https://www.blaess.fr/christophe/>, Stéphan Rafin
<
[email protected]>, Thierry Vignaud
<
[email protected]>, François Micaux, Alain Portal
<
[email protected]>, Jean-Philippe Guérard
<
[email protected]>, Jean-Luc Coulon (f5ibh)
<
[email protected]>, Julien Cristau
<
[email protected]>, Thomas Huriaux <
[email protected]>,
Nicolas François <
[email protected]>, Florentin
Duneau <
[email protected]>, Simon Paillard
<
[email protected]>, Denis Barbier
<
[email protected]>, David Prévot <
[email protected]>,
Cédric Boutillier <
[email protected]>,
Frédéric Hantrais <
[email protected]> et Jean-Pierre
Giraud <
[email protected]>
Cette traduction est une documentation libre ; veuillez vous reporter
à la
GNU
General Public License version 3 concernant les conditions de copie
et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel,
veuillez envoyer un message à
[email protected]