.\" -*- coding: UTF-8 -*- .\" Copyright (C) 2016 Michael Kerrisk .\" and Copyright (C) 2016 Eugene Syromyatnikov .\" A very few fragments remain from an earlier version of this page .\" written by David Howells (dhowells@redhat.com) .\" .\" %%%LICENSE_START(VERBATIM) .\" Permission is granted to make and distribute verbatim copies of this .\" manual provided the copyright notice and this permission notice are .\" preserved on all copies. .\" .\" Permission is granted to copy and distribute modified versions of this .\" manual under the conditions for verbatim copying, provided that the .\" entire resulting derived work is distributed under the terms of a .\" permission notice identical to this one. .\" .\" Since the Linux kernel and libraries are constantly changing, this .\" manual page may be incorrect or out-of-date. The author(s) assume no .\" responsibility for errors or omissions, or for damages resulting from .\" the use of the information contained herein. The author(s) may not .\" have taken the same level of care in the production of this manual, .\" which is licensed free of charge, as they might when working .\" professionally. .\" .\" Formatted or processed versions of this manual, if unaccompanied by .\" the source, must acknowledge the copyright and authors of this work. .\" %%%LICENSE_END .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH KEYCTL 2 "1 novembre 2020" Linux "Gestion des clés sous Linux" .SH NOM keyctl \- Manipuler la gestion des clés du noyau .SH SYNOPSIS .nf \fB#include \fP \fB#include \fP .PP \fBlong keyctl(int \fP\fIoperation\fP\fB, ...);\fP \fB/* Pour un appel direct à l'aide de syscall(2) : */\fP \fB#include \fP \fB#include \fP \fB#include \fP .PP \fBlong syscall(__NR_keyctl, int \fP\fIoperation\fP\fB, __kernel_ulong_t \fP\fIarg2\fP\fB,\fP \fB __kernel_ulong_t \fP\fIarg3\fP\fB, __kernel_ulong_t \fP\fIarg4\fP\fB,\fP \fB __kernel_ulong_t \fP\fIarg5\fP\fB);\fP .fi .PP Aucune enveloppe n'est fournie pour la glibc pour cet appel système\ ; voir les NOTES. .SH DESCRIPTION \fBkeyctl\fP() permet aux programmes de l'espace utilisateur de manipuler des clés. .PP L'opération qu'effectue \fBkeyctl\fP() dépend de la valeur du paramètre \fIoperation\fP. Chacune de ces opérations fait partie de l'enveloppe de la bibliothèque \fIlibkeyutils\fP (fournie par le paquet \fIkeyutils\fP) en tant que fonctions individuelles (indiquées ci\-dessous) pour permettre au compilateur de vérifier les types. .PP Les valeurs autorisées pour \fIoperation\fP sont\ : .TP \fBKEYCTL_GET_KEYRING_ID\fP (depuis Linux\ 2.6.10) Associer l'identifiant d'une clé spéciale à celui d'une clé réelle pour ce processus. .IP Cette opération recherche la clé spéciale dont l'identifiant est fourni dans \fIarg2\fP (transmis à \fIkey_serial_t\fP). Si la clé spéciale est trouvée, l'identifiant de la clé réelle correspondante est renvoyé en tant que résultat de la fonction. Les valeurs suivantes peuvent être indiquées dans \fIarg2\fP\ : .RS .TP \fBKEY_SPEC_THREAD_KEYRING\fP Pour indiquer le trousseau spécifique au thread du thread appelant. Voir \fBthread\-keyring\fP(7). .TP \fBKEY_SPEC_PROCESS_KEYRING\fP Pour indiquer le trousseau spécifique au processus de l'appelant. Voir \fBprocess\-keyring\fP(7). .TP \fBKEY_SPEC_SESSION_KEYRING\fP Pour indiquer le trousseau spécifique à la session de l'appelant. Voir \fBsession\-keyring\fP(7). .TP \fBKEY_SPEC_USER_KEYRING\fP Pour indiquer le trousseau spécifique à l'UID de l'appelant. Voir \fBuser\-keyring\fP(7). .TP \fBKEY_SPEC_USER_SESSION_KEYRING\fP Pour indiquer le trousseau spécifique à la session de l'UID de l'appelant. Voir \fBuser\-session\-keyring\fP(7). .TP \fBKEY_SPEC_REQKEY_AUTH_KEY\fP (depuis Linux 2.6.16) .\" commit b5f545c880a2a47947ba2118b2509644ab7a2969 Cela indique la clé d'autorisation créée par \fBrequest_key\fP(2) et passée au processus qu'il produit pour générer une clé. Cette clé n'est disponible que dans un programme à la manière de \fBrequest\-key\fP(8) où une clé d'autorisation a été passée par le noyau et cesse d’être disponible lorsque la clé demandée a été instanciée\ ; voir \fBrequest_key\fP(2). .TP \fBKEY_SPEC_REQUESTOR_KEYRING\fP (depuis Linux\ 2.6.29) .\" commit 8bbf4976b59fc9fc2861e79cab7beb3f6d647640 Cela indique l'identifiant de la clé pour le trousseau de destination \fBrequest_key\fP(2). Ce trousseau n'est disponible que dans un programme dans le style de \fBrequest\-key\fP(8) où une clé d'autorisation a été passée par le noyau et cesse d’être disponible une fois que la clé demandée a été instanciée\ ; voir \fBrequest_key\fP(2). .RE .IP .\" The keyctl_get_keyring_ID.3 page says that a new key .\" "will be created *if it is appropriate to do so**. What is the .\" determiner for appropriate? .\" David Howells: Some special keys such as KEY_SPEC_REQKEY_AUTH_KEY .\" wouldn't get created but user/user-session/session keyring would .\" be created. Si la clé indiquée dans \fIarg2\fP n'existe pas, le comportement dépend de la valeur de \fIarg3\fP (diffusée dans \fIint\fP). Si \fIarg3\fP contient une valeur non nulle —\ et s'il est utile de le faire (comme pour rechercher un utilisateur, une session utilisateur ou une clé de session)\ —, une nouvelle clé est créée et son identifiant de clé réelle est renvoyé en tant que résultat de la fonction. Sinon, l'opération échoue avec l'erreur \fBENOKEY\fP. .IP Si un identifiant de clé valable est indiqué dans \fIarg2\fP et si la clé existe, cette opération renvoie simplement l'identifiant de la clé. Si la clé n'existe pas, l'appel échoue avec l'erreur \fBENOKEY\fP. .IP L'appelant doit avoir le droit \fIsearch\fP sur un trousseau pour qu’il soit trouvable. .IP Les paramètres \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_get_keyring_ID\fP(3). .TP \fBKEYCTL_JOIN_SESSION_KEYRING\fP (depuis Linux 2.6.10) .\" This may be useful in conjunction with some sort of .\" session management framework that is employed by the application. Remplacer le trousseau de la session à laquelle le processus est rattaché par un nouveau trousseau de session. .IP Si \fIarg2\fP vaut NULL, un trousseau anonyme dont la description est «\ _ses\ » est créé et le processus est inscrit à ce trousseau en tant que trousseau de sa session, remplaçant le trousseau de la session précédente. .IP Sinon, \fIarg2\fP (diffusé dans \fIchar\ *\fP) est traité comme la description (le nom) d'un trousseau et le comportement est ainsi\ : .RS .IP * 3 Si un trousseau ayant une description correspondante existe, le processus tentera de s'inscrire à ce trousseau en tant que trousseau de session si c'est possible\ ; sans quoi une erreur est renvoyée. Pour s'inscrire au trousseau, l'appelant doit avoir le droit \fIsearch\fP sur le trousseau. .IP * Si un trousseau avec une description correspondante n'existe pas, un nouveau trousseau ayant la description indiquée est créé et le processus est inscrit à ce trousseau en tant que trousseau de session. .RE .IP Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP par la fonction \fBkeyctl_join_session_keyring\fP(3). .TP \fBKEYCTL_UPDATE\fP (depuis Linux 2.6.10) Mettre à jour la charge utile des données d'une clé. .IP Le paramètre \fIarg2\fP (diffusé sur \fIkey_serial_t\fP) indique l'identifiant de la clé à mettre à jour. Le paramètre \fIarg3\fP (diffusé sur \fIvoid\ *\fP) pointe vers la nouvelle charge utile et \fIarg4\fP (diffusé sur \fIsize_t\fP) contient la taille de la nouvelle charge utile (en octets). .IP L'appelant doit avoir les droits \fIwrite\fP sur la clé indiquée et le type de clé doit gérer les mises à jour. .IP Une clé instanciée négativement (voir la description de \fBKEYCTL_REJECT\fP) peut être instanciée positivement avec cette opération. .IP Le paramètre \fIarg5\fP est ignoré. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_update\fP(3). .TP \fBKEYCTL_REVOKE\fP (depuis Linux 2.6.10) Révoquer la clé dont l'identifiant est fourni dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). La clé est vouée à aller à la poubelle\ ; elle ne sera plus trouvable et ne sera plus disponible pour de futures opérations. Les futures tentatives d'utiliser la clé échoueront avec l'erreur \fBEKEYREVOKED\fP. .IP .\" Keys with the KEY_FLAG_KEEP bit set cause an EPERM .\" error for KEYCTL_REVOKE. Does this need to be documented? .\" David Howells: No significance for user space. L'appelant doit avoir les droits \fIwrite\fP ou \fIsetattr\fP sur la clé. .IP Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_revoke\fP(3). .TP \fBKEYCTL_CHOWN\fP (depuis Linux 2.6.10) Changer le propriétaire (identifiant de l'utilisateur et du groupe) d'une clé. .IP Le paramètre \fIarg2\fP (diffusé sur \fIkey_serial_t\fP) contient l'identifiant de la clé. Le paramètre \fIarg3\fP (diffusé sur \fIuid_t\fP) contient l'identifiant du nouvel utilisateur (ou \fB\-1\fP s'il ne doit pas être modifié). Le paramètre \fIarg4\fP (diffusé sur \fIgid_t\fP) contient l'identifiant du nouveau groupe (ou \fB\-1\fP s'il ne doit pas être modifié). .IP La clé doit accorder le droit \fIsetattr\fP à l'appelant. .IP Pour pouvoir modifier l'identifiant utilisateur ou utiliser un identifiant de groupe dont l'appelant n'est pas membre, l'appelant doit avoir la capacité \fBCAP_SYS_ADMIN\fP (voir \fBcapabilities\fP(7)). .IP Si l'identifiant utilisateur doit être modifié, le nouvel utilisateur doit avoir un quota suffisant pour accepter la clé. La déduction du quota sera déplacée de l’ancien utilisateur vers le nouveau à condition que l’UID ait changé. .IP Le paramètre \fIarg5\fP est ignoré. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_chown\fP(3). .TP \fBKEYCTL_SETPERM\fP (depuis Linux 2.6.10) Passer les droits de la clé dont l'identifiant est fourni dans le paramètre \fIarg2\fP (diffusé sur \fIkey_serial_t\fP) à ceux fournis dans le paramètre \fIarg3\fP (diffusé sur \fIkey_perm_t\fP). .IP Si l'appelant n'a pas la capacité \fBCAP_SYS_ADMIN\fP, il ne peut modifier que les droits des clés qu'il possède. (Plus précisément, l’UID du système de fichiers de l’appelant doit correspondre à l’UID de la clé.) .IP .\" FIXME Above, is it really intended that a privileged process can't .\" override the lack of the 'setattr' permission? La clé doit accorder le droit \fIsetattr\fP à l'appelant \fIindépendamment\fP de ses capacités. .IP Les droits dans \fIarg3\fP indiquent les masques des opérations disponibles pour chacune des catégories suivantes d'utilisateur\ : .RS .TP \fIpossessor\fP (depuis Linux 2.6.14) .\" commit 664cceb0093b755739e56572b836a99104ee8a75 Il s'agit des droits accordés à un processus possédant la clé (en tant qu'il est rattaché à un des trousseaux du processus trouvables)\ ; voir \fBkeyrings\fP(7). .TP \fIuser\fP Il s'agit du droit accordé à un processus dont l'identifiant utilisateur du système de fichiers correspond à celui de la clé. .TP \fIgroup\fP Il s'agit du droit accordé au processus dont l'identifiant de groupe du système de fichiers ou un de ses identifiants de groupes supplémentaires correspond à celui de la clé. .TP \fIother\fP Il s'agit du droit accordé aux autres processus qui ne rentrent pas dans les catégories \fIuser\fP et \fIgroup\fP. .RE .IP Les catégories \fIuser\fP, \fIgroup\fP et \fIother\fP sont exclusives\ : si un processus rentre dans la catégorie \fIuser\fP, il ne recevra pas de droits dans la catégorie \fIgroup\fP\ ; s'il rentre dans la catégorie \fIuser\fP ou \fIgroup\fP, il ne recevra aucun droit de la catégorie \fIother\fP. .IP La catégorie \fIpossessor\fP accorde des droits qui s'ajoutent à ceux accordés en vertu des catégories \fIuser\fP, \fIgroup\fP ou \fIother\fP. .IP Chaque masque de droits pèse huit bits, dont seuls six sont actuellement utilisés. Les droits disponibles sont\ : .RS .TP \fIview\fP Droit de lire les attributs d'une clé. .IP Ce droit est nécessaire pour l'opération \fBKEYCTL_DESCRIBE\fP. .IP Les bits de droit pour chaque catégorie sont \fBKEY_POS_VIEW\fP, \fBKEY_USR_VIEW\fP, \fBKEY_GRP_VIEW\fP et \fBKEY_OTH_VIEW\fP. .TP \fIread\fP Lire la charge utile d'une clé. .IP Ce droit est nécessaire pour l'opération \fBKEYCTL_READ\fP. .IP Les bits de droit pour chaque catégorie sont \fBKEY_POS_READ\fP, \fBKEY_USR_READ\fP, \fBKEY_GRP_READ\fP et \fBKEY_OTH_READ\fP. .TP \fIwrite\fP Mettre à jour ou instancier une clé. Pour un trousseau, attacher ou détacher des clés d'un trousseau. .IP Ce droit est nécessaire pour les opérations \fBKEYCTL_UPDATE\fP, \fBKEYCTL_REVOKE\fP, \fBKEYCTL_CLEAR\fP, \fBKEYCTL_LINK\fP et \fBKEYCTL_UNLINK\fP. .IP Les bits des droits pour chaque catégorie sont \fBKEY_POS_WRITE\fP, \fBKEY_USR_WRITE\fP, \fBKEY_GRP_WRITE\fP et \fBKEY_OTH_WRITE\fP. .TP \fIsearch\fP Rechercher dans les trousseaux et rendre les clés trouvables. Les recherches ne peuvent parcourir des trousseaux imbriqués que si les droits \fIsearch\fP y sont positionnés. .IP Ce droit est nécessaire pour les opérations \fBKEYCTL_GET_KEYRING_ID\fP, \fBKEYCTL_JOIN_SESSION_KEYRING\fP, \fBKEYCTL_SEARCH\fP et \fBKEYCTL_INVALIDATE\fP. .IP Les bits de droit pour chaque catégorie sont \fBKEY_POS_SEARCH\fP, \fBKEY_USR_SEARCH\fP, \fBKEY_GRP_SEARCH\fP et \fBKEY_OTH_SEARCH\fP. .TP \fIlink\fP Rattacher une clé ou un trousseau. .IP Ce droit est nécessaire pour les opérations \fBKEYCTL_LINK\fP et \fBKEYCTL_SESSION_TO_PARENT\fP. .IP Les bits des droits pour cette catégorie sont \fBKEY_POS_LINK\fP, \fBKEY_USR_LINK\fP, \fBKEY_GRP_LINK\fP et \fBKEY_OTH_LINK\fP. .TP \fIsetattr\fP (depuis Linux 2.6.15). Modifier un identifiant d'utilisateur, de groupe ou le masque de droits d'une clé. .IP Ce droit est nécessaire pour les opérations \fBKEYCTL_REVOKE\fP, \fBKEYCTL_CHOWN\fP et \fBKEYCTL_SETPERM\fP. .IP Les bits de droits pour chaque catégorie sont \fBKEY_POS_SETATTR\fP, \fBKEY_USR_SETATTR\fP, \fBKEY_GRP_SETATTR\fP et \fBKEY_OTH_SETATTR\fP. .RE .IP Par commodité, les macros suivantes sont définies en tant que masques pour tous les bits de droits de chacune des catégories de l'utilisateur\ : \fBKEY_POS_ALL\fP, \fBKEY_USR_ALL\fP, \fBKEY_GRP_ALL\fP et \fBKEY_OTH_ALL\fP. .IP Les paramètres \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_setperm\fP(3). .TP \fBKEYCTL_DESCRIBE\fP (depuis Linux 2.6.10) Obtenir une chaîne décrivant les attributs d'une clé indiquée. .IP L'identifiant de la clé à décrire est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). La chaîne de description est renvoyée dans le tampon vers lequel pointe \fIarg3\fP (diffusé sur \fIchar\ *\fP)\ ; \fIarg4\fP (diffusé sur \fIsize_t\fP) indique la taille de ce tampon en octets. .IP La clé doit accorder le droit \fIview\fP à l'appelant. .IP La chaîne renvoyée se termine par NULL et contient les informations suivantes sur la clé\ : .IP .in +4n \fItype\fP;\fIuid\fP;\fIgid\fP;\fIperm\fP;\fIdescription\fP .in .IP Dans ce qui précède, \fItype\fP et \fIdescription\fP sont des chaînes, \fIuid\fP et \fIgid\fP sont des chaînes décimales et \fIperm\fP est un masque de droits hexadécimal. La chaîne de description est écrite dans le format suivant\ : .IP %s;%d;%d;%08x;%s .IP .\" FIXME But, the kernel does not enforce the requirement .\" that the key description contains no semicolons! .\" So, user space has no guarantee here?? .\" Either something more needs to be said here, .\" or a kernel fix is required. \fBNote\ : l'objectif est d'étendre la chaîne de description dans les futures versions du noyau\fP. En particulier, le champ \fIdescription\fP ne contiendra pas de point\-virgule\ ; elle doit être analysée en partant de la fin pour chercher le dernier point\-virgule. Cela permettra, à l'avenir, d'insérer des champs délimités avec des points\-virgules. .IP .\" Function commentary says it copies up to buflen bytes, but see the .\" (buffer && buflen >= ret) condition in keyctl_describe_key() in .\" security/keyctl.c Une tentative d'écrire dans le tampon n'a lieu que lorsque \fIarg3\fP n'est pas NULL et quand la taille du tampon indiquée est assez grande pour accepter la chaîne de description (y compris l'octet NULL final). Afin de déterminer si la taille du tampon était trop petite, vérifiez que la valeur de retour de l'opération est supérieure à \fIarg4\fP. .IP Le paramètre \fIarg5\fP est ignoré. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_describe\fP(3). .TP \fBKEYCTL_CLEAR\fP Vider le contenu (à savoir détacher les clés) d'un trousseau. .IP .\" or the error ENOTDIR results .\" According to Documentation/security/keys.txt: .\" This function can also be used to clear special kernel keyrings if they .\" are appropriately marked if the user has CAP_SYS_ADMIN capability. The .\" DNS resolver cache keyring is an example of this. L'identifiant de la clé (qui doit être de type trousseau) est fourni dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). .IP L'appelant doit avoir le droit \fIwrite\fP sur le trousseau. .IP Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_clear\fP(3). .TP \fBKEYCTL_LINK\fP (depuis Linux 2.6.10) Créer un lien d'un trousseau vers une clé. .IP La clé à rattacher est indiquée dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP)\ ; le trousseau est indiqué dans \fIarg3\fP (diffusé sur \fIkey_serial_t\fP). .IP Si une clé du même type et ayant la même description se trouve déjà rattachée au trousseau, elle est éliminée du trousseau. .IP Avant de créer le rattachement, le noyau vérifie la profondeur des trousseaux et renvoie les erreurs adéquates si le rattachement crée une boucle ou si la profondeur des trousseaux serait trop importante (la limite de profondeur est définie par la constante \fBKEYRING_SEARCH_MAX_DEPTH\fP du noyau, fixée à 6, et elle est nécessaire pour empêcher les débordements de de la pile du noyau lors d'une recherche récursive de trousseaux). .IP L'appelant doit avoir le droit \fIlink\fP sur la clé à ajouter et celui \fIwrite\fP sur le trousseau. .IP Les paramètres \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_link\fP(3). .TP \fBKEYCTL_UNLINK\fP (depuis Linux 2.6.10) Supprimer une clé d'un trousseau. .IP L'identifiant de la clé à détacher est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP)\ ; l'identifiant du trousseau d'où la clé doit être détachée est indiqué dans \fIarg3\fP (diffusé sur \fIkey_serial_t\fP). .IP Si la clé n'est pas rattachée au trousseau, cela produit une erreur. .IP L'appelant doit avoir le droit \fIwrite\fP sur le trousseau d'où doit être détachée la clé. .IP Si le dernier rattachement d'une clé est supprimé, cette clé sera mise en destruction. .IP Les paramètres \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_unlink\fP(3). .TP \fBKEYCTL_SEARCH\fP (depuis Linux 2.6.10) Chercher une clé dans l'arborescence d'un trousseau, renvoyer son identifiant et, éventuellement, la rattacher à un trousseau indiqué. .IP L'arborescence où doit s'effectuer la recherche est indiquée en passant l'identifiant de la clé de tête à \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). La recherche s'effectue en largeur et récursivement. .IP Les paramètres \fIarg3\fP et \fIarg4\fP indiquent la clé à rechercher\ : \fIarg3\fP (diffusé en tant que \fIchar\ *\fP) contient le type de clé (une chaîne de caractères se terminant par NULL et mesurant jusqu'à 32\ octets en comptant l'octet NULL final), et \fIarg4\fP (diffusé en tant que \fIchar\ *\fP) contient la description de la clé (une chaîne de caractères se terminant par NULL et mesurant jusqu'à 4096\ octets en comptant l'octet NULL final). .IP Le trousseau d'origine doit autoriser l'appelant à \fIsearch\fP. Pendant la recherche récursive, seuls les trousseaux accordant le droit \fIsearch\fP à l'appelant seront explorés. Seules les clés pour lesquelles l'appelant a le droit \fIsearch\fP seront trouvées. .IP Si la clé est trouvée, son identifiant est renvoyé en tant que résultat de la fonction. .IP Si la clé est trouvée et si \fIarg5\fP (diffusé sur \fIkey_serial_t\fP) n'est pas zéro, la clé est rattachée au trousseau indiqué dont l'identifiant est indiqué dans \fIarg5\fP, avec les mêmes contraintes et les mêmes règles que \fBKEYCTL_LINK\fP. Si le trousseau cible indiqué dans \fIarg5\fP contient déjà une clé rattachée du même type et à la même description, cet attachement sera remplacé par un autre avec la clé trouvée avec cette opération. .IP Plutôt que des identifiants de trousseaux existants valables, les trousseaux d'origine (\fIarg2\fP) et cible (\fIarg5\fP) peuvent être un des identifiants de trousseau de clés spéciales indiqué dans \fBKEYCTL_GET_KEYRING_ID\fP. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_search\fP(3). .TP \fBKEYCTL_READ\fP (depuis Linux 2.6.10) Lire les données de la charge utile (\fIpayload\fP) d'une clé. .IP .\" including KEY_SPEC_REQKEY_AUTH_KEY L'identifiant de la clé dont la charge utile va être lue est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). Il peut s'agir de l'identifiant d'une clé existante ou un identifiant de clé spéciale listé dans \fBKEYCTL_GET_KEYRING_ID\fP. .IP La charge utile est mise dans le tampon vers lequel pointe \fIarg3\fP (diffusé sur \fIchar\ *\fP)\ ; la taille de ce tampon doit être indiquée dans \fIarg4\fP (diffusé sur \fIsize_t\fP). .IP Les données renvoyées seront traitées pour être présentées en fonction du type de clé. Par exemple, un trousseau renverra un tableau d'entrées \fIkey_serial_t\fP qui représentent les identifiants de toutes les clés qui y sont rattachées. Le type de clé \fIuser\fP renverra ses données telles quelles. Si un type de clé n'implémente pas cette fonction, l'opération échoue avec l'erreur \fBEOPNOTSUPP\fP. .IP Si \fIarg3\fP n'est pas NULL, autant de données que possible de la charge utile seront copiées dans le tampon. En cas de renvoi d'un succès, la valeur est toujours la taille totale des données de la charge utile. Pour savoir si le tampon était de taille suffisante, vérifiez que la valeur de retour est inférieure ou égale à celle fournie dans \fIarg4\fP. .IP La clé doit accorder à l'appelant le droit \fIread\fP, ou bien lui accorder le droit \fIsearch\fP quand elle est recherchée depuis les trousseaux d'un processus (à savoir quand elle est détenue). .IP Le paramètre \fIarg5\fP est ignoré. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_read\fP(3). .TP \fBKEYCTL_INSTANTIATE\fP (depuis Linux 2.6.10) Instancier (positivement) une clé non instanciée avec une charge utile indiquée .IP L'identifiant de la clé à instancier est fournie dans \fIarg2\fP (diffusée sur \fIkey_serial_t\fP). .IP La charge utile de la clé est indiquée dans le tampon vers lequel pointe \fIarg3\fP (diffusé sur \fIvoid\ *\fP)\ ; la taille de ce tampon est indiquée dans \fIarg4\fP (diffusée sur \fIsize_t\fP). .IP La charge utile peut être un pointeur NULL et la taille du tampon peut être de \fB0\fP si cela est pris en charge par le type de clé (si c'est un trousseau, par exemple). .IP L'opération peut échouer si les données de charge utile sont dans un mauvais format ou non valables pour toute autre raison. .IP Si \fIarg5\fP (diffusé sur \fIkey_serial_t\fP) n'est pas zéro, la clé instanciée est rattachée au trousseau dont l'identifiant a été indiqué dans \fIarg5\fP, avec les mêmes contraintes et les mêmes règles que \fBKEYCTL_LINK\fP. .IP L'appelant doit avoir la clé d'autorisation adéquate, et une fois que la clé non instanciée a été instanciée, la clé d'autorisation est révoquée. Autrement dit, cette opération n'est disponible qu'à partir d'un programme de style \fBrequest\-key\fP(8). Voir \fBrequest_key\fP(2) pour une explication sur les clés non instanciées et l'instanciation de clés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_instantiate\fP(3). .TP \fBKEYCTL_NEGATE\fP (depuis Linux 2.6.10) Instancier négativement une clé non instanciée. .IP Cette opération est équivalente à l'appel\ : .IP keyctl(KEYCTL_REJECT, arg2, arg3, ENOKEY, arg4); .IP Le paramètre \fIarg5\fP est ignoré. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_negate\fP(3). .TP \fBKEYCTL_SET_REQKEY_KEYRING\fP (depuis Linux 2.6.10) .\" I.e., calls to the kernel's internal request_key() interface, .\" which is distinct from the request_key(2) system call (which .\" ultimately employs the kernel-internal interface). Définir le trousseau par défaut auquel les clés demandées implicitement seront rattachées pour ce thread et renvoyer la configuration précédente. Les requêtes de clé implicites sont celles que des composants du noyau effectuent en interne, comme par exemple lors de l'ouverture de fichiers sur des systèmes de fichiers AFS ou NFS. Le fait de définir un trousseau par défaut produit également des effets lors d'une demande de clé depuis l'espace utilisateur\ ; voir \fBrequest_key\fP(2) pour les détails. .IP Le paramètre \fIarg2\fP (diffusé sur \fIint\fP) doit contenir une des valeurs suivantes pour indiquer le nouveau trousseau par défaut\ : .RS .TP \fBKEY_REQKEY_DEFL_NO_CHANGE\fP Ne pas modifier le trousseau par défaut. Cela peut servir à rechercher le trousseau par défaut actuel (sans le modifier). .TP \fBKEY_REQKEY_DEFL_DEFAULT\fP Cela sélectionne le comportement par défaut qui consiste à utiliser le trousseau spécifique au thread s'il y en a un, ou sinon celui spécifique au processus s'il y en a un, ou bien celui spécifique à la session s'il y en a un, ou sinon celui de la session spécifique de l'identifiant utilisateur, ou celui spécifique à l'utilisateur. .TP \fBKEY_REQKEY_DEFL_THREAD_KEYRING\fP Utiliser le trousseau spécifique du thread (\fBthread\-keyring\fP(7)) en tant que nouveau trousseau par défaut. .TP \fBKEY_REQKEY_DEFL_PROCESS_KEYRING\fP Utiliser le trousseau spécifique au processus (\fBprocess\-keyring\fP(7)) en tant que nouveau trousseau par défaut. .TP \fBKEY_REQKEY_DEFL_SESSION_KEYRING\fP Utiliser le trousseau spécifique à la session (\fBsession\-keyring\fP(7)) en tant que nouveau trousseau par défaut. .TP \fBKEY_REQKEY_DEFL_USER_KEYRING\fP Utiliser le trousseau spécifique à l'identifiant utilisateur (\fBuser\-keyring\fP(7)) en tant que nouveau trousseau par défaut. .TP \fBKEY_REQKEY_DEFL_USER_SESSION_KEYRING\fP Utiliser le trousseau de la session spécifique de l'identifiant utilisateur (\fBuser\-session\-keyring\fP(7)) en tant que nouveau trousseau par défaut. .TP \fBKEY_REQKEY_DEFL_REQUESTOR_KEYRING\fP (depuis Linux 2.6.29) .\" 8bbf4976b59fc9fc2861e79cab7beb3f6d647640 .\" FIXME The preceding explanation needs to be expanded. .\" Is the following correct: .\" .\" The requestor keyring is the dest_keyring that .\" was supplied to a call to request_key(2)? .\" .\" David Howells said: to be checked Utiliser le trousseau du demandeur. .RE .IP .\" (including the still-unsupported KEY_REQKEY_DEFL_GROUP_KEYRING) Toutes les autres valeurs ne sont pas valables. .IP Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Le paramètre que contrôle cette opération est récupéré par l'enfant de \fBfork\fP(2) et conservé durant un \fBexecve\fP(2). .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_set_reqkey_keyring\fP(3). .TP \fBKEYCTL_SET_TIMEOUT\fP (depuis Linux 2.6.10) Définir un délai d'expiration sur une clé. .IP L'identifiant de la clé est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). La valeur du délai, en seconde à partir de l'heure actuelle, est indiquée dans \fIarg3\fP (diffusé sur \fIunsigned int\fP). Le délai se mesure par rapport à l'horloge en temps réel. .IP L'indication d'une valeur de délai de \fB0\fP vide les délais existants de la clé. .IP Le fichier \fI/proc/keys\fP affiche le temps restant avant l'expiration de chaque clé (il s'agit de la seule méthode de recherche du temps de vie d'une clé). .IP L'appelant doit avoir le droit \fIsetattr\fP sur la clé ou détenir un jeton d'autorisation d’instanciation pour cette clé (voir \fBrequest_key\fP(2)). .IP La clé et les liens vis\-à\-vis d'elle seront automatiquement mis à la poubelle après le délai d'expiration. Les futurs essais d'y accéder échoueront avec l'erreur \fBEKEYEXPIRED\fP. .IP Cette opération ne peut pas être utilisée pour poser des limites à des clés révoquées, expirées ou instanciées négativement. .IP Les paramètres \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_set_timeout\fP(3). .TP \fBKEYCTL_ASSUME_AUTHORITY\fP (depuis Linux 2.6.10) Assumer (ou se débarrasser) de l'autorité pour le thread appelant pour instancier une clé. .IP Ce paramètre \fIarg2\fP (diffusé sur \fIkey_serial_t\fP) fait assumer l'autorité à un identifiant de clé autre que zéro, ou retire l'autorité grâce à la valeur \fB0\fP. .IP Si \fIarg2\fP n'est pas zéro, il indique un identifiant de clé non instanciée qui devra assumer l'autorité. Cette clé peut alors être instanciée en utilisant \fBKEYCTL_INSTANTIATE\fP, \fBKEYCTL_INSTANTIATE_IOV\fP, \fBKEYCTL_REJECT\fP ou \fBKEYCTL_NEGATE\fP. Quand la clé a été instanciée, le thread se voit automatiquement retirer le pouvoir d'instancier la clé. .IP Une clé ne peut assumer une autorité que si le thread appelant a dans ses trousseaux la clé d'autorisation associée à la clé (autrement dit, l'opération \fBKEYCTL_ASSUME_AUTHORITY\fP n'est disponible qu'à partir d'un programme du style \fBrequest\-key\fP(8)\ ; voir \fBrequest_key\fP(2) pour une explication sur la manière dont cette opération est utilisée). L'appelant doit avoir le droit \fIsearch\fP sur la clé d'autorisation. .IP Si la clé indiquée a une clé d'autorisation associée, l'identifiant de cette clé est renvoyé. La clé d'autorisation peut être lue (\fBKEYCTL_READ\fP) pour obtenir les informations d'appel transmises à \fBrequest_key\fP(2). .IP Si l'identifiant fourni dans \fIarg2\fP est \fB0\fP, l'autorité actuellement assumée est retirée et la valeur \fB0\fP est renvoyée. .IP Le mécanisme \fBKEYCTL_ASSUME_AUTHORITY\fP permet à un programme tel que \fBrequestkey\fP(8) d'assumer l'autorité nécessaire pour instancier une nouvelle clé non instanciée créée suite à un appel à \fBrequest_key\fP(2). Pour plus d'informations, voir \fBrequest_key\fP(2) et le fichier \fIDocumentation/security/keys\-request\-key.txt\fP des sources du noyau. .IP Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_assume_authority\fP(3). .TP \fBKEYCTL_GET_SECURITY\fP (depuis Linux 2.6.26) .\" commit 70a5bb72b55e82fbfbf1e22cae6975fac58a1e2d Récupérer l'étiquette de sécurité LSM (Linux Security Module) de la clé indiquée. .IP L'identifiant de la clé dont l'étiquette doit être récupérée est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). L'étiquette de sécurité (qui se termine par un octet NULL) sera mis dans le tampon vers lequel pointe \fIarg3\fP (diffusé sur \fIchar\ *\fP)\ ; la taille du tampon doit être fournie dans \fIarg4\fP (diffusée sur \fIsize_t\fP). .IP Si \fIarg3\fP est indiqué en tant que NULL ou si la taille du tampon indiquée dans \fIarg4\fP est trop petite, toute la taille de la chaîne de l'étiquette de sécurité (y compris l'octet NULL de fin) est renvoyée en tant que résultat de la fonction et rien n'est copié dans le tampon. .IP L'appelant doit avoir le droit \fIview\fP sur la clé indiquée. .IP La chaîne de l'étiquette de sécurité renvoyée sera affichée sous la bonne forme sur le LSM en mode force. Par exemple, avec SELinux, elle peut ressembler à\ : .IP unconfined_u:unconfined_r:unconfined_t:s0\-s0:c0.c1023 .IP Si aucun LSM n'est en mode force, une chaîne vide est placée dans le tampon. .IP Le paramètre \fIarg5\fP est ignoré. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide des fonctions \fBkeyctl_get_security\fP(3) et \fBkeyctl_get_security_alloc\fP(3). .TP \fBKEYCTL_SESSION_TO_PARENT\fP (depuis Linux 2.6.32) .\" commit ee18d64c1f632043a02e6f5ba5e045bb26a5465f .\" What is the use case for KEYCTL_SESSION_TO_PARENT? .\" David Howells: the Process Authentication Groups people requested this, .\" but then didn't use it; maybe there are no users. Remplacer le trousseau de session auquel est enregistré le \fIparent\fP du processus appelant par celui du processus appelant. .IP Le trousseau sera remplacé dans le processus parent sur les prochains points de transition du parent entre l'espace noyau et l'espace utilisateur. .IP Le trousseau doit exister et accorder le droit \fIlink\fP à l'appelant. Le processus parent doit être single\-threaded et appartenir au même utilisateur/groupe effectif que ce processus, et il ne doit pas être set\-user\-ID ou set\-group\-ID. L'identifiant utilisateur du trousseau de la session existante du processus parent (s'il en existe un) et celui du trousseau de session de l'appelant doivent correspondre à celui de l'identifiant utilisateur effectif de l'appelant. .IP Le fait que le processus parent soit touché par cette opération permet à un programme tel qu'un interpréteur de démarrer un processus enfant qui utilise cette opération pour modifier le trousseau de session de l'interpréteur (c'est ce que fait la commande \fBnew_session\fP de \fBkeyctl\fP(1)). .IP Les paramètres \fIarg2\fP, \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_session_to_parent\fP(3). .TP \fBKEYCTL_REJECT\fP (depuis Linux 2.6.39) .\" commit fdd1b94581782a2ddf9124414e5b7a5f48ce2f9c Marquer une clé comme étant instanciée négativement et positionner une durée d'expiration sur la clé. Cette opération ajoute un supplément à l'opération \fBKEYCTL_NEGATE\fP ci\-dessus. .IP L'identifiant de la clé à instancier négativement est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). Le paramètre \fIarg3\fP (diffusé sur \fIunsigned int\fP) indique la durée de vie de la clé en seconde. Le paramètre \fIarg4\fP (diffusé sur \fIunsigned int\fP) indique l'erreur à renvoyer quand une recherche trouve cette clé\ ; généralement il s'agit de \fBEKEYREJECTED\fP, \fBEKEYREVOKED\fP ou \fBEKEYEXPIRED\fP. .IP Si \fIarg5\fP (diffusé sur \fIkey_serial_t\fP) n'est pas nul, la clé instanciée négativement est rattachée au trousseau dont l'identifiant est indiqué dans \fIarg5\fP, avec les mêmes contraintes et les mêmes règles que \fBKEYCTL_LINK\fP. .IP L'appelant doit avoir la clé d'autorisation adéquate. Autrement dit, cette opération n'est disponible qu'à partir d'un programme dans le style \fBrequest\-key\fP(8). Voir \fBrequest_key\fP(2). .IP L'appelant doit avoir la clé d'autorisation adéquate, et une fois que la clé non instanciée a été instanciée, la clé d'autorisation est révoquée. Autrement dit, cette opération n'est disponible qu'à partir d'un programme de style \fBrequest\-key\fP(8). Voir \fBrequest_key\fP(2) pour une explication sur les clés non instanciées et l'instanciation de clés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_reject\fP(3). .TP \fBKEYCTL_INSTANTIATE_IOV\fP (depuis Linux 2.6.39) .\" commit ee009e4a0d4555ed522a631bae9896399674f063 Instancier une clé non instanciée avec la charge utile indiquée à l'aide d'un vecteur de tampons. .IP Cette opération est la même que \fBKEYCTL_INSTANTIATE\fP, mais les données de la charge utile sont indiquées sous forme d'un tableau de structures \fIiovec\fP\ : .IP .in +4n .EX struct iovec { void *iov_base; /* Début de l'adresse du tampon */ size_t iov_len; /* Taille du tampon (en octets) */ }; .EE .in .IP Le pointeur vers le vecteur de charge utile est indiqué dans \fIarg3\fP (diffusé en tant que \fIconst struct iovec\ *\fP). Le nombre d'éléments du vecteur est indiqué dans \fIarg4\fP (diffusé en tant que \fIunsigned int\fP). .IP \fIarg2\fP (identifiant de clé) et \fIarg5\fP (identifiant de trousseau) sont interprétés avec \fBKEYCTL_INSTANTIATE\fP. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_instantiate_iov\fP(3). .TP \fBKEYCTL_INVALIDATE\fP (depuis Linux 3.5) .\" commit fd75815f727f157a05f4c96b5294a4617c0557da Marquer une clé comme non valable. .IP L'identifiant de la clé à rendre non valable est indiqué dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). .IP .\" CAP_SYS_ADMIN is permitted to invalidate certain special keys Pour rendre une clé non valable, l'appelant doit avoir le droit \fIsearch\fP sur la clé. .IP Cette opération marque la clé comme non valable et programme sa mise immédiate à la corbeille. Le ramasse\-miettes, supprime les clés non valables de tous les trousseaux et efface la clé quand son nombre de références atteint \fB0\fP. Après cette opération, cette clé sera ignorée par toutes les recherches, même si elle n'est pas encore effacée. .IP Les clés marquées comme non valables deviennent aussitôt invisibles pour les opérations de clé normales, bien qu'elle soient encore visibles dans \fI/proc/keys\fP (avec un drapeau «\ i\ ») jusqu'à ce qu'elles soient totalement supprimées. .IP Les paramètres \fIarg3\fP, \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_invalidate\fP(3). .TP \fBKEYCTL_GET_PERSISTENT\fP (depuis Linux 3.13) .\" commit f36f8c75ae2e7d4da34f4c908cebdb4aa42c977e Récupérer le trousseau persistant (\fBpersistent\-keyring\fP(7)) d'un utilisateur indiqué et le rattacher au trousseau indiqué. .IP L'identifiant utilisateur est indiqué dans \fIarg2\fP (diffusé sur \fIuid_t\fP). Si la valeur \fB\-1\fP est indiquée, l'identifiant de l'utilisateur réel de l'appelant est utilisé. L'identifiant du trousseau de destination est indiqué dans \fIarg3\fP (diffusé sur \fIkey_serial_t\fP). .IP L'appelant doit avoir la capacité \fBCAP_SETUID\fP dans son espace de noms utilisateur afin de récupérer le trousseau persistant pour un identifiant utilisateur qui ne correspond pas à l'identifiant utilisateur réel ou effectif de l'appelant. .IP Si l'appel réussit, un lien vers le trousseau persistant est ajouté au trousseau dont l'identifiant a été indiqué dans \fIarg3\fP. .IP L'appelant doit avoir le droit \fIwrite\fP sur le trousseau. .IP Le trousseau persistant sera créé par le noyau s'il n'existe pas encore. .IP Chaque fois que l'opération \fBKEYCTL_GET_PERSISTENT\fP est effectuée, le trousseau persistant aura un délai d'expiration réinitialisé à la valeur dans\ : .IP .in +4n .EX /proc/sys/kernel/keys/persistent_keyring_expiry .EE .in .IP Lorsque le délai est atteint, le trousseau persistant sera supprimé et son contenu pourra être collecté par le ramasse\-miettes. .IP Des trousseaux persistants ont été ajoutés à Linux dans le noyau version\ 3.13. .IP Les paramètres \fIarg4\fP et \fIarg5\fP sont ignorés. .IP Cette opération est mise à disposition par \fIlibkeyutils\fP à l'aide de la fonction \fBkeyctl_get_persistent\fP(3). .TP \fBKEYCTL_DH_COMPUTE\fP (depuis Linux 4.7) .\" commit ddbb41148724367394d0880c516bfaeed127b52e Calculer la clé secrète Diffie\-Hellman partagée ou la clé publique, en appliquant éventuellement une fonction de dérivation de clé (KDF) au résultat. .IP Le paramètre \fIarg2\fP est un pointeur vers un ensemble de paramètres contenant les numéros de série de trois clés \fI«\ utilisateur\ »\fP utilisés dans le calcul Diffie\-Hellman, empaquetés dans une structure de la forme suivante\ : .IP .in +4n .EX struct keyctl_dh_params { int32_t private; /* La clé privée locale */ int32_t prime; /* Le nombre premier, connue des deux côtés */ int32_t base; /* L'entier de base\ : soit un générateur partagé, soit la clé publique distante */ }; .EE .in .IP Chacune des trois clés indiquées dans cette structure doit accorder le droit \fIread\fP à l'appelant. Les charges utiles de ces clés sont utilisées pour calculer le résultat Diffie\-Hellman ainsi\ : .IP base \(ha private mod prime .IP Si la base est le générateur partagé, le résultat est la clé publique locale. Si la base est la clé publique distante, le résultat est le code secret partagé. .IP Le paramètre \fIarg3\fP (diffusé sur \fIchar\*\fP) pointe vers un tampon où est mis le résultat du calcul. La taille de ce tampon est indiquée dans \fIarg4\fP (diffusé sur \fIsize_t\fP). .IP Le tampon doit être assez grand pour accueillir les données de sortie, sans quoi une erreur est renvoyée. Si \fIarg4\fP vaut zéro, le tampon n'est pas utilisé et l'opération renvoie la taille minimale requise du tampon (à savoir la longueur du nombre premier). .IP Les calculs Diffie\-Hellman peuvent être effectués dans l'espace utilisateur mais exigent une bibliothèque multiprécision d'entiers (MPI). Le déplacement de l'implémentation dans le noyau donne accès à l'implémentation MPI du noyau et permet d'accéder à la sécurisation et à l'accélération matérielle. .IP .\" commit f1c316a3ab9d24df6022682422fe897492f2c0c8 L'ajout de la prise en charge du calcul DH à l'appel système \fBkeyctl\fP() a été considéré comme convenable grâce à l'utilisation de l'algorithme DH pour faire dériver les clés partagées\ ; cela permet aussi au type de clé de déterminer l'implémentation DH adéquate (logicielle ou matérielle). .IP Si le paramètre \fIarg5\fP vaut \fBNULL\fP, le résultat DH lui\-même est renvoyé. Sinon, (depuis Linux\ 4.12), il s'agit d'un pointeur vers une structure qui indique les paramètres de l'opération KDF à appliquer\ : .IP .in +4n .EX struct keyctl_kdf_params { char *hashname; /* Nom de l'algorithm de hachage */ char *otherinfo; /* SP800\-56A OtherInfo */ __u32 otherinfolen; /* Taille des données otherinfo */ __u32 __spare[8]; /* Réservé */ }; .EE .in .IP Le champ \fIhashname\fP est une chaîne se terminant par NULL qui indique un nom de hachage (disponible dans l'API de chiffrement du noyau\ ; la liste des hachages disponibles est plutôt difficile à examiner\ ; veuillez vous reporter à la documentation de la .UR https://www.kernel.org\:/doc\:/html\:/latest\:/crypto\:/architecture.html «\ Kernel Crypto API Architecture\ » .UE pour des informations sur la manière dont les noms de hachage sont construits, et aux sources et à la configuration de votre noyau concernant les chiffrements et les modèles de type \fBCRYPTO_ALG_TYPE_SHASH\fP disponibles) à appliquer au résultat DH dans l'opération KDF. .IP Le champ \fIotherinfo\fP consiste dans des données \fIOtherInfo\fP comme décrit dans la section\ 5.8.1.2 de SP800\-56A et il est spécifique à l'algorithme. Ces données sont concaténées avec le résultat de l'opération DH et elles sont fournies comme entrée de l'opération KDF. Leur taille est fournie dans le champ \fIotherinfolen\fP et limitée à la constante \fBKEYCTL_KDF_MAX_OI_LEN\fP définie dans \fIsecurity/keys/internal.h\fP à la valeur\ 64. .IP .\" commit 4f9dabfaf8df971f8a3b6aa324f8f817be38d538 Le champ \fB__spare\fP est actuellement inusité. Il était ignoré jusqu'à Linux\ 4.13 (mais il est encore visible par l'utilisateur puisqu'il est copié dans le noyau) et il devrait contenir des zéros depuis Linux\ 4.13. .IP L'implémentation KDF se conforme à SP800\-56A et à SP800\-108 (le compteur KDF). .IP .\" keyutils commit 742c9d7b94051d3b21f9f61a73ed6b5f3544cb82 .\" keyutils commit d68a981e5db41d059ac782071c35d1e8f3aaf61c Cette opération est mise à disposition par \fIlibkeyutils\fP (depuis la version\ 1.5.10 jusqu'à aujourd'hui) à l'aide de la fonction \fBkeyctl_dh_compute\fP(3) et de \fBkeyctl_dh_compute_alloc\fP(3). .TP \fBKEYCTL_RESTRICT_KEYRING\fP (depuis Linux 4.12) .\" commit 6563c91fd645556c7801748f15bc727c77fcd311 .\" commit 7228b66aaf723a623e578aa4db7d083bb39546c9 Appliquer une restriction de rattachement de clé à un trousseau dont l'identifiant est fourni dans \fIarg2\fP (diffusé sur \fIkey_serial_t\fP). L'appelant doit avoir le droit \fIsetattr\fP sur la clé. Si \fIarg3\fP vaut NULL, toute tentative d'ajout au trousseau est bloquée\ ; sinon il contient un pointeur vers une chaîne contenant le nom du type de clé et \fIarg4\fP contient un pointeur vers une chaîne contenant la restriction spécifique au type de clé. À partir de Linux\ 4.12, seul le type «\ asymmetric\ » a des restrictions définies\ : .RS .TP \fBbuiltin_trusted\fP N'autoriser que les clés signées par une clé rattachée au trousseau interne («\ .builtin_trusted_keys\ »). .TP \fBbuiltin_and_secondary_trusted\fP N'autoriser que les clés signées par une clé rattachée à un trousseau secondaire («\ .secondary_trusted_keys\ ») ou, par extension, à une clé du trousseau interne, puisque le deuxième est lié au premier. .TP \fBkey_or_keyring:\fP\fIkey\fP .TQ \fBkey_or_keyring:\fP\fIkey\fP\fB:chain\fP Si \fIkey\fP indique l'identifiant d'une clé de type «\ asymmetric\ », seules les clés signées par cette clé sont autorisées. .IP Si \fIkey\fP indique l'identifiant d'un trousseau, seules les clés signées par une clé rattachée à ce trousseau sont autorisées. .IP Si «\ :chain\ » est indiqué, les clés signées par une clé rattachée au trousseau de destination (c'est\-à\-dire le trousseau dont l'identifiant est indiqué dans le paramètre \fIarg2\fP) sont aussi autorisées. .RE .IP Remarquez qu'une restriction ne peut être configurée qu'une fois pour le trousseau indiqué\ ; une fois qu'une restriction est positionnée, elle ne peut pas être contournée. .IP .\" FIXME Document KEYCTL_RESTRICT_KEYRING, added in Linux 4.12 .\" commit 6563c91fd645556c7801748f15bc727c77fcd311 .\" Author: Mat Martineau .\" See Documentation/security/keys.txt Le paramètre \fIarg5\fP est ignoré. .SH "VALEUR RENVOYÉE" Pour qu'un appel réussisse, le code de retour dépend de l'opération\ : .TP \fBKEYCTL_GET_KEYRING_ID\fP L'identifiant du trousseau demandé. .TP \fBKEYCTL_JOIN_SESSION_KEYRING\fP L'identifiant du trousseau de la session qu'on vient de rejoindre. .TP \fBKEYCTL_DESCRIBE\fP La taille de la description (comprenant l'octet NULL de fin) indépendamment de la taille du tampon fournie. .TP \fBKEYCTL_SEARCH\fP L'identifiant de la clé trouvée. .TP \fBKEYCTL_READ\fP La quantité de données disponibles dans la clé, indépendamment de la taille du tampon fournie. .TP \fBKEYCTL_SET_REQKEY_KEYRING\fP L'identifiant du trousseau par défaut précédent auquel ont été rattachées implicitement les clés sollicitées (un parmi \fBKEY_REQKEY_DEFL_USER_*\fP). .TP \fBKEYCTL_ASSUME_AUTHORITY\fP \fB0\fP si l'identifiant donné valait \fB0\fP, ou l'identifiant de la clé d'autorisation correspondant à la clé indiquée, si un identifiant de clé autre que zéro a été fourni. .TP \fBKEYCTL_GET_SECURITY\fP La taille de la chaîne de l'étiquette de sécurité LSM (y compris l'octet NULL de fin), indépendamment de la taille du tampon fourni. .TP \fBKEYCTL_GET_PERSISTENT\fP L'identifiant du trousseau persistant. .TP \fBKEYCTL_DH_COMPUTE\fP Le nombre d'octets copiés dans le tampon ou, si \fIarg4\fP vaut \fB0\fP, la taille du tampon nécessaire. .TP Toutes les autres opérations Zéro. .PP En cas d'erreur, \fB\-1\fP est renvoyé et \fIerrno\fP est positionné adéquatement pour indiquer l'erreur. .SH ERREURS .TP \fBEACCES\fP L'opération demandée n'était pas autorisée. .TP \fBEAGAIN\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et une erreur s'est produite lors de l'initialisation du module de chiffrement. .TP \fBEDEADLK\fP \fIoperation\fP était \fBKEYCTL_LINK\fP et le rattachement demandé conduirait à une boucle. .TP \fBEDEADLK\fP \fIoperation\fP était \fBKEYCTL_RESTRICT_KEYRING\fP et la restriction de trousseau demandée aboutirait à une boucle. .TP \fBEDQUOT\fP Le quota de clés de l'utilisateur appelant serait dépassé si la clé était créée ou ajoutée au trousseau. .TP \fBEEXIST\fP \fIoperation\fP était \fBKEYCTL_RESTRICT_KEYRING\fP et le trousseau fourni dans le paramètre \fIarg2\fP comporte déjà une restriction. .TP \fBEFAULT\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et une des actions suivantes a échoué\ : .RS .IP \(bu 3 copie de la \fIstruct keyctl_dh_params\fP, fournie dans le paramètre \fIarg2\fP, depuis l'espace utilisateur\ ; .IP \(bu copie de la \fIstruct keyctl_kdf_params\fP, fournie dans l'argument non NULL \fIarg5\fP, depuis l'espace utilisateur (si le noyau gère l'opération KDF lors du résultat de l'opération DH)\ ; .IP \(bu copie des données vers lesquelles pointe le champ \fIhashname\fP de la \fIstruct keyctl_kdf_params\fP à partir de l'espace utilisateur\ ; .IP \(bu copie des données vers lesquelles pointe le champ \fIotherinfo\fP de la \fIstruct keyctl_kdf_params\fP depuis l'espace utilisateur si le champ \fIotherinfolen\fP n'était pas zéro\ ; .IP \(bu copie du résultat vers l'espace utilisateur. .RE .TP \fBEINVAL\fP \fIoperation\fP était \fBKEYCTL_SETPERM\fP et un bit de droit non valable a été indiqué dans \fIarg3\fP. .TP \fBEINVAL\fP \fIoperation\fP était \fBKEYCTL_SEARCH\fP et la taille de la description dans \fIarg4\fP (y compris l'octet NULL final) dépassait 4096\ octets. La taille de la chaîne (y compris l'octet NULL final) indiquée dans \fIarg3\fP (le type de clé) ou dans \fIarg4\fP (la description de la clé) dépassait les limites (respectivement 32 et 4096\ octets). .TP \fBEINVAL\fP (noyaux Linux antérieurs à 4.12) \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP, le paramètre \fIarg5\fP n'était pas NULL. .TP \fBEINVAL\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et la taille de l’empreinte numérique de l'algorithme de hachage fourni est de zéro. .TP \fBEINVAL\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et la taille du tampon fournie n'est pas suffisante pour contenir le résultat. Mettez \fB0\fP en tant que taille de tampon pour obtenir la taille minimale du tampon. .TP \fBEINVAL\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et le nom de hachage fourni dans le champ \fIhashname\fP de la \fIstruct keyctl_kdf_params\fP vers laquelle pointe le paramètre \fIarg5\fP est trop grand (la limite est spécifique à l'implémentation et varie entre les versions du noyau, mais elle est considérée comme suffisante pour tous les noms d'algorithmes valables). .TP \fBEINVAL\fP .\" commit 4f9dabfaf8df971f8a3b6aa324f8f817be38d538 \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et le champ \fI__spare\fP de la \fIstruct keyctl_kdf_params\fP fournie dans le paramètre \fIarg5\fP contient des valeurs autres que zéro. .TP \fBEKEYEXPIRED\fP Une clé expirée a été trouvée ou spécifiée. .TP \fBEKEYREJECTED\fP Une clé rejetée a été trouvée ou spécifiée. .TP \fBEKEYREVOKED\fP Une clé révoquée a été trouvée ou spécifiée. .TP \fBELOOP\fP \fIoperation\fP était \fBKEYCTL_LINK\fP et le rattachement demandé ferait dépasser la profondeur maximale d’imbrication des trousseaux. .TP \fBEMSGSIZE\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et la longueur du tampon dépasse \fBKEYCTL_KDF_MAX_OUTPUT_LEN\fP (qui est actuellement de 1024) ou le champ \fIotherinfolen\fP de la \fIstruct keyctl_kdf_parms\fP fournie dans \fIarg5\fP dépasse \fBKEYCTL_KDF_MAX_OI_LEN\fP (qui est actuellement de 64). .TP \fBENFILE\fP (noyaux Linux avant le 3.13) .\" commit b2a4df200d570b2c33a57e1ebfa5896e4bc81b69 \fIoperation\fP était \fBKEYCTL_LINK\fP et le trousseau est complet (avant Linux\ 3.13, l'espace disponible de stockage de rattachements de trousseaux était limité à une seule page mémoire\ ; depuis Linux\ 3.13, il n'y a pas de limite fixée). .TP \fBENOENT\fP \fIoperation\fP était \fBKEYCTL_UNLINK\fP et la clé à détacher n'est pas rattachée au trousseau. .TP \fBENOENT\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et l'algorithme de hachage indiqué dans le champ \fIhashname\fP de la \fIstruct keyctl_kdf_params\fP vers laquelle pointe le paramètre \fIarg5\fP n'a pas été trouvé. .TP \fBENOENT\fP \fIoperation\fP était \fBKEYCTL_RESTRICT_KEYRING\fP et le type fourni dans le paramètre \fIarg3\fP ne gère pas la définition de restrictions de rattachement de clés. .TP \fBENOKEY\fP Aucune clé correspondante n'a été trouvée, ou une clé non valable a été spécifiée. .TP \fBENOKEY\fP La valeur \fBKEYCTL_GET_KEYRING_ID\fP était indiquée dans \fIoperation\fP, la clé indiquée dans \fIarg2\fP n'existait pas et \fIarg3\fP valait zéro (ce qui veut dire ne pas créer de clé si elle n'existe pas). .TP \fBENOMEM\fP Une des routines de l'allocation mémoire du noyau a échoué lors de l'exécution de l'appel système. .TP \fBENOTDIR\fP Une clé de type trousseau était attendue mais l'identifiant d'une clé de type différent a été fourni. .TP \fBEOPNOTSUPP\fP \fIoperation\fP était \fBKEYCTL_READ\fP et le type de clé ne gère pas la lecture (par exemple, le type est \fI«\ login\ »\fP). .TP \fBEOPNOTSUPP\fP \fIoperation\fP était \fBKEYCTL_UPDATE\fP et le type de clé ne gère pas les mises à jour. .TP \fBEOPNOTSUPP\fP \fIoperation\fP était \fBKEYCTL_RESTRICT_KEYRING\fP, le type fourni dans le paramètre \fIarg3\fP était «\ asymmetric\ », et la clé indiquée dans la spécification de la restriction fournie dans \fIarg4\fP a un autre type que «\ asymmetric\ » ou «\ keyring\ ». .TP \fBEPERM\fP \fIoperation\fP était \fBKEYCTL_GET_PERSISTENT\fP, \fIarg2\fP indiquait un identifiant utilisateur différent de celui de l'utilisateur réel ou effectif du thread appelant, et l'appelant n'avait pas la capacité \fBCAP_SETUID\fP. .TP \fBEPERM\fP \fIoperation\fP était \fBKEYCTL_SESSION_TO_PARENT\fP et\ : soit tous les identifiants utilisateur (ou de groupe) du processus parent ne correspondent pas à celui effectif du processus appelant\ ; soit l'identifiant utilisateur du trousseau de session du parent, ou celui du trousseau de session de l'appelant, ne correspondait pas à l'identifiant de l'utilisateur effectif de l'appelant\ ; soit le processus parent se compose de plus d'un thread\ ; soit le processus parent est \fBinit\fP(1) ou un thread du noyau. .TP \fBETIMEDOUT\fP \fIoperation\fP était \fBKEYCTL_DH_COMPUTE\fP et l'initialisation des modules de chiffrement a dépassé le délai. .SH VERSIONS Cet appel système est apparu pour la première fois dans Linux\ 2.6.10. .SH CONFORMITÉ Cet appel système est une extension Linux non standard. .SH NOTES Aucune enveloppe pour cet appel système n'est fournie dans la glibc. Une enveloppe est fournie dans la bibliothèque \fIlibkeyutils\fP. Quand on utilise une enveloppe de cette bibliothèque, liez\-la avec \fI\-lkeyutils\fP. Cependant, plutôt que d'utiliser cet appel système directement, vous voudrez probablement utiliser les fonctions de la bibliothèque mentionnées dans les descriptions des opérations individuelles ci\-dessus. .SH EXEMPLES Le programme ci\-dessous fournit un sous\-ensemble de fonctions du programme \fBrequest\-key\fP(8) fourni par le paquet \fIkeyutils\fP. Pour information, le programme enregistre diverses informations dans un fichier journal. .PP Comme indiqué dans \fBrequest_key\fP(2), le programme \fBrequest\-key\fP(8) est appelé avec les paramètres de la ligne de commande qui décrivent une clé à instancier. Le programme exemple récupère et enregistre ces arguments. Le programme endosse l'autorité d'instancier la clé demandée, puis il instancie cette clé. .PP La session d'interpréteur suivante montre l'utilisation de ce programme. Dans la session, nous compilons le programme, puis nous l'utilisons pour remplacer temporairement le programme \fBrequest\-key\fP(8) standard (remarquez que la désactivation temporaire du programme standard \fBrequest\-key\fP(8) peut ne pas être sure sur certains systèmes). Tant que notre programme exemple est installé, nous utilisons le programme exemple présent dans \fBrequest_key\fP(2) pour demander une clé. .PP .in +4n .EX $ \fBcc \-o key_instantiate key_instantiate.c \-lkeyutils\fP $ \fBsudo mv /sbin/request\-key /sbin/request\-key.backup\fP $ \fBsudo cp key_instantiate /sbin/request\-key\fP $ \fB./t_request_key user mykey somepayloaddata\fP L'identifiant de clé est 20d035bf $ \fBsudo mv /sbin/request\-key.backup /sbin/request\-key\fP .EE .in .PP En regardant le fichier journal créé par ce programme, on peut voir les paramètres de la ligne de commande fournis à notre programme exemple\ : .PP .in +4n .EX $ \fBcat /tmp/key_instantiate.log\fP Time: Mon Nov 7 13:06:47 2016 Command line arguments: argv[0]: /sbin/request\-key operation: create key_to_instantiate: 20d035bf UID: 1000 GID: 1000 thread_keyring: 0 process_keyring: 0 session_keyring: 256e6a6 Key description: user;1000;1000;3f010000;mykey Auth key payload: somepayloaddata Destination keyring: 256e6a6 Auth key description: .request_key_auth;1000;1000;0b010000;20d035bf .EE .in .PP Les dernières lignes de la sortie ci\-dessus montrent que le programme exemple a pu récupérer\ : .IP * 3 la description de la clé à instanciée, qui incluait le nom de la clé (\fImykey\fP)\ ; .IP * la charge utile de la clé d'autorisation, qui consistait dans des données (\fIsomepayloaddata\fP) passées à \fBrequest_key\fP(2)\ ; .IP * le trousseau de destination indiqué dans l'appel à \fBrequest_key\fP(2)\ ; .IP * la description de la clé d'autorisation où on peut voir que le nom de la clé correspond à l'identifiant de celle à instancier (\fI20d035bf\fP). .PP Le programme exemple dans \fBrequest_key\fP(2) indiquait le trousseau de destination en tant que \fBKEY_SPEC_SESSION_KEYRING\fP. En examinant le contenu de \fI/proc/keys\fP, on peut voir que cela a été transcrit dans l'identifiant du trousseau de destination (\fI0256e6a6\fP) affiché dans le fichier journal ci\-dessus\ ; on peut aussi voir la clé nouvellement créée dont le nom est \fImykey\fP et l'identifiant est \fI20d035bf\fP. .PP .in +4n .EX $ \fBcat /proc/keys | egrep \(aqmykey|256e6a6\(aq\fP 0256e6a6 I\-\-Q\-\-\- 194 perm 3f030000 1000 1000 keyring _ses: 3 20d035bf I\-\-Q\-\-\- 1 perm 3f010000 1000 1000 user mykey: 16 .EE .in .SS "Source du programme" \& .EX /* key_instantiate.c */ #include #include #include #include #include #include #include #include #include #include #ifndef KEY_SPEC_REQUESTOR_KEYRING #define KEY_SPEC_REQUESTOR_KEYRING \-8 #endif int main(int argc, char *argv[]) { FILE *fp; time_t t; char *operation; key_serial_t key_to_instantiate, dest_keyring; key_serial_t thread_keyring, process_keyring, session_keyring; uid_t uid; gid_t gid; char dbuf[256]; char auth_key_payload[256]; int akp_size; /* Size of auth_key_payload */ int auth_key; fp = fopen("/tmp/key_instantiate.log", "w"); if (fp == NULL) exit(EXIT_FAILURE); setbuf(fp, NULL); t = time(NULL); fprintf(fp, "Time: %s\en", ctime(&t)); /* * Le noyau passe un ensemble fixe de paramètres au programme * qu'il exécute ; les récupérer. */ operation = argv[1]; key_to_instantiate = atoi(argv[2]); uid = atoi(argv[3]); gid = atoi(argv[4]); thread_keyring = atoi(argv[5]); process_keyring = atoi(argv[6]); session_keyring = atoi(argv[7]); fprintf(fp, "Paramètres de la ligne de commande\ :\en"); fprintf(fp, " argv[0]: %s\en", argv[0]); fprintf(fp, " operation: %s\en", operation); fprintf(fp, " key_to_instantiate: %jx\en", (uintmax_t) key_to_instantiate); fprintf(fp, " UID: %jd\en", (intmax_t) uid); fprintf(fp, " GID: %jd\en", (intmax_t) gid); fprintf(fp, " thread_keyring: %jx\en", (uintmax_t) thread_keyring); fprintf(fp, " process_keyring: %jx\en", (uintmax_t) process_keyring); fprintf(fp, " session_keyring: %jx\en", (uintmax_t) session_keyring); fprintf(fp, "\en"); /* * Assumer l'autorité pour instancier la clé nommée dans argv[2] */ if (keyctl(KEYCTL_ASSUME_AUTHORITY, key_to_instantiate) == \-1) { fprintf(fp, "KEYCTL_ASSUME_AUTHORITY a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } /* * Récupérer la description de la clé à instancier */ if (keyctl(KEYCTL_DESCRIBE, key_to_instantiate, dbuf, sizeof(dbuf)) == \-1) { fprintf(fp, "KEYCTL_DESCRIBE a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } fprintf(fp, "Description de clé : %s\en", dbuf); /* * Récupérer la charge utile de la clé d'autorisation, qui est en fait * les données d'appel (callout) données à request_key() */ akp_size = keyctl(KEYCTL_READ, KEY_SPEC_REQKEY_AUTH_KEY, auth_key_payload, sizeof(auth_key_payload)); if (akp_size == \-1) { fprintf(fp, "KEYCTL_READ a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } auth_key_payload[akp_size] = \(aq\e0\(aq; fprintf(fp, "Charge utile de la clé d'auth : %s\en", auth_key_payload); /* * Par intérêt, récupérer l'identifiant de la clé d'autorisation et * l'afficher. */ auth_key = keyctl(KEYCTL_GET_KEYRING_ID, KEY_SPEC_REQKEY_AUTH_KEY); if (auth_key == \-1) { fprintf(fp, "KEYCTL_GET_KEYRING_ID a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } fprintf(fp, "Identifiant de la clé d'auth : %jx\en", (uintmax_t) auth_key); /* * Récupérer l'identifiant de clé pour le trousseau de destination * request_key(2). */ dest_keyring = keyctl(KEYCTL_GET_KEYRING_ID, KEY_SPEC_REQUESTOR_KEYRING); if (dest_keyring == \-1) { fprintf(fp, "KEYCTL_GET_KEYRING_ID a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } fprintf(fp, "Trousseau de destination : %jx\en", (uintmax_t) dest_keyring); /* * Récupérer la description de la clé d'autorisation. Cela nous permet * de voir le type de clé, l'identifiant utilisateur et de groupe, les * droits et la description (nom) de la clé. Entre autres choses, * on verra que le nom de la clé est une chaîne hexadécimale représentant * l'identifiant de la clé à instancier. */ if (keyctl(KEYCTL_DESCRIBE, KEY_SPEC_REQKEY_AUTH_KEY, dbuf, sizeof(dbuf)) == \-1) { fprintf(fp, "KEYCTL_DESCRIBE a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } fprintf(fp, "Description de la clé d'auth : %s\en", dbuf); /* * Instancier la clé en utilisant les données de l'appel (callout) * fournies dans la charge utile de la clé d'autorisation. */ if (keyctl(KEYCTL_INSTANTIATE, key_to_instantiate, auth_key_payload, akp_size + 1, dest_keyring) == \-1) { fprintf(fp, "KEYCTL_INSTANTIATE a échoué : %s\en", strerror(errno)); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); } .EE .SH "VOIR AUSSI" .ad l .nh .\" .BR find_key_by_type_and_name (3) .\" There is a man page, but this function seems not to exist \fBkeyctl\fP(1), \fBadd_key\fP(2), \fBrequest_key\fP(2), \fBkeyctl\fP(3), \fBkeyctl_assume_authority\fP(3), \fBkeyctl_chown\fP(3), \fBkeyctl_clear\fP(3), \fBkeyctl_describe\fP(3), \fBkeyctl_describe_alloc\fP(3), \fBkeyctl_dh_compute\fP(3), \fBkeyctl_dh_compute_alloc\fP(3), \fBkeyctl_get_keyring_ID\fP(3), \fBkeyctl_get_persistent\fP(3), \fBkeyctl_get_security\fP(3), \fBkeyctl_get_security_alloc\fP(3), \fBkeyctl_instantiate\fP(3), \fBkeyctl_instantiate_iov\fP(3), \fBkeyctl_invalidate\fP(3), \fBkeyctl_join_session_keyring\fP(3), \fBkeyctl_link\fP(3), \fBkeyctl_negate\fP(3), \fBkeyctl_read\fP(3), \fBkeyctl_read_alloc\fP(3), \fBkeyctl_reject\fP(3), \fBkeyctl_revoke\fP(3), \fBkeyctl_search\fP(3), \fBkeyctl_session_to_parent\fP(3), \fBkeyctl_set_reqkey_keyring\fP(3), \fBkeyctl_set_timeout\fP(3), \fBkeyctl_setperm\fP(3), \fBkeyctl_unlink\fP(3), \fBkeyctl_update\fP(3), \fBrecursive_key_scan\fP(3), \fBrecursive_session_key_scan\fP(3), \fBcapabilities\fP(7), \fBcredentials\fP(7), \fBkeyrings\fP(7), \fBkeyutils\fP(7), \fBpersistent\-keyring\fP(7), \fBprocess\-keyring\fP(7), \fBsession\-keyring\fP(7), \fBthread\-keyring\fP(7), \fBuser\-keyring\fP(7), \fBuser_namespaces\fP(7), \fBuser\-session\-keyring\fP(7), \fBrequest\-key\fP(8) .PP Les fichiers sources du noyau \fIDocumentation/security/keys/\fP (ou avant Linux\ 4.13, dans le fichier \fIDocumentation/security/keys.txt\fP). .SH COLOPHON Cette page fait partie de la publication\ 5.10 du projet \fIman\-pages\fP Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man\-pages/. .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot et Jean-Philippe MENGUAL . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .