perkamon - en to fr translation catalogue (209 entries)

note: type: TH
en: 2021-03-22
fr: 22 mars 2021

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: keyrings - in-kernel key management and retention facility
fr: keyrings – gestion interne au noyau de clés et mémorisation

note: type: Plain text
en: The Linux key-management facility is primarily a way for various kernel components to retain or cache security data, authentication keys, encryption keys, and other data in the kernel.
fr: La fonction de gestion de clés de Linux est principalement un moyen pour divers composants du noyau de mémoriser ou de mettre en cache des données de sécurité, des clés d’authentification, des clés de chiffrement et d’autres données dans le noyau.

note: type: Plain text
en: System call interfaces are provided so that user-space programs can manage those objects and also use the facility for their own purposes; see B<add_key>(2), B<request_key>(2), and B<keyctl>(2).
fr: Les interfaces d’appel système sont fournies de façon à ce que les programmes en espace utilisateur puissent gérer ces objets, et aussi utiliser la fonctionnalité pour leurs propres besoins. Consultez B<add_key>(2), B<request_key>(2) et B<keyctl>(2).

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: A library and some user-space utilities are provided to allow access to the facility.  See B<keyctl>(1), B<keyctl>(3), and B<keyutils>(7)  for more information.
fr: Une bibliothèque et quelques utilitaires en espace utilisateur sont fournies pour autoriser l’accès à cette fonctionnalité. Consultez B<keyctl>(1), B<keyctl>(3) et B<keyutils>(7) pour davantage d’informations.

note: type: SS
en: Keys
fr: Clés

note: type: Plain text
en: A key has the following attributes:
fr: Une clé possède les attributs suivants :

note: type: TP
en: Serial number (ID)
fr: Numéro de série (ID)

note: type: Plain text
en: This is a unique integer handle by which a key is referred to in system calls.  The serial number is sometimes synonymously referred as the key ID.  Programmatically, key serial numbers are represented using the type I<key_serial_t>.
fr: IL s’agit d’un entier unique par lequel une clé est référencée dans des appels système. Le numéro de série est parfois de manière synonyme appelée l’identifiant de clé. En programmation, les numéros de série sont représentés en utilisant le type I<key_serial_t>.

note: type: Plain text
en: A key's type defines what sort of data can be held in the key, how the proposed content of the key will be parsed, and how the payload will be used.
fr: Le type de clé précise quelle sorte de données sera gérée par la clé, de quelle manière le contenu présenté par la clé sera analysé et comment la charge utile sera utilisée.

note: type: Plain text
en: There are a number of general-purpose types available, plus some specialist types defined by specific kernel components.
fr: Un certain nombre de types génériques sont disponibles en plus de types spécialisés définis par des composants particuliers du noyau.

note: type: TP
en: Description (name)
fr: Description (nom)

note: type: Plain text
en: The key description is a printable string that is used as the search term for the key (in conjunction with the key type) as well as a display name.  During searches, the description may be partially matched or exactly matched.
fr: La description de la clé est une chaîne affichable qui est utilisée comme terme de recherche de la clé (en conjonction du type de la clé) ainsi que comme nom à afficher. Lors des recherches, la description peut correspondre partiellement ou totalement.

note: type: TP
en: Payload (data)
fr: Charge utile (données)

note: type: Plain text
en: The payload is the actual content of a key.  This is usually set when a key is created, but it is possible for the kernel to upcall to user space to finish the instantiation of a key if that key wasn't already known to the kernel when it was requested.  For further details, see B<request_key>(2).
fr: La charge utile est le contenu réel de la clé. C’est habituellement défini au moment de la création de la clé, mais il est possible qu’un appel montant (upcall) du noyau dans l’espace utilisateur finisse l’instanciation de la clé si celle-ci n’était pas connue du noyau quand elle est demandée. Pour plus de détails, consultez B<request_key>(2).

note: type: Plain text
en: A key's payload can be read and updated if the key type supports it and if suitable permission is granted to the caller.
fr: Une charge utile de clé peut être lue et mise à jour si le type de clé le gère et si les permissions adéquates sont données à l’appelant.

note: type: SS
en: Access rights
fr: Droits d’accès

note: type: Plain text
en: Much as files do, each key has an owning user ID, an owning group ID, and a security label.  Each key also has a set of permissions, though there are more than for a normal UNIX file, and there is an additional category\(empossessor\(embeyond the usual user, group, and other (see I<Possession>, below).
fr: De la même manière que pour les fichiers, chaque clé possède un ID utilisateur, un ID de groupe et une étiquette de sécurité. Chaque clé possède aussi un ensemble de permissions, bien qu’il existe autre chose que les UNIX normaux, et il existe une catégorie supplémentaire – possesseur — en plus des utilisateur, groupe et autres. Consultez I<Possesseur>, ci-dessous).

note: type: Plain text
en: Note that keys are quota controlled, since they require unswappable kernel memory.  The owning user ID specifies whose quota is to be debited.
fr: Il est à remarquer que les clés sont sujettes à un quota puisqu’elles nécessitent de la mémoire du noyau non « swappable ». L’ID de l’utilisateur propriétaire indique quel quota doit être débité.

note: type: TP
en: Expiration time
fr: Heure d’expiration

note: type: Plain text
en: Each key can have an expiration time set.  When that time is reached, the key is marked as being expired and accesses to it fail with the error B<EKEYEXPIRED>.  If not deleted, updated, or replaced, then, after a set amount of time, an expired key is automatically removed (garbage collected)  along with all links to it, and attempts to access the key fail with the error B<ENOKEY>.
fr: Chaque clé peut avoir une heure d’expiration définie. Quand ce moment est atteint, la clé est marquée comme périmée et sa demande échouera avec l’erreur B<EKEYEXPIRED>. Si elle n’est pas supprimée, mise à jour ou remplacée, alors après un certain temps, la clé ayant expirée est automatiquement supprimée (collectée par le ramasse-miettes) avec tous les liens vers elle, et les essais d’obtenir cette clé échoueront avec l’erreur B<ENOKEY>.

note: type: TP
en: Reference count
fr: Comptage de références

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: Each key has a reference count.  Keys are referenced by keyrings, by currently active users, and by a process's credentials.  When the reference count reaches zero, the key is scheduled for garbage collection.
fr: Chaque clé possède un comptage de références. Les clés sont référencées par des trousseaux de clés en fonction des utilisateurs actifs actuels et en fonction des identifiants de processus. Quand le comptage de références atteint zéro, la clé est programmée pour le ramasse-miettes.

note: type: SS
en: Key types
fr: Types de clé

note: type: Plain text
en: The kernel provides several basic types of key:
fr: Le noyau fournit plusieurs types basiques de clé :

note: Note that keyrings use different fields in struct key in order to store their data - index_key instead of type/description and name_link/keys instead of payload. type: Plain text
en: Keyrings are special keys which store a set of links to other keys (including other keyrings), analogous to a directory holding links to files.  The main purpose of a keyring is to prevent other keys from being garbage collected because nothing refers to them.
fr: Les trousseaux de clés sont des clés spéciales qui stockent un ensemble de liens vers d’autres clés (incluant d’autres trousseaux de clés), de manière analogue à un répertoire contenant des liens vers des fichiers. L’objectif principal d’un trousseau de clés est d’empêcher d’autres clés d’être collectées par le ramasse-miettes parce qu’elles ne servent de références à rien.

note: type: Plain text
en: Keyrings with descriptions (names)  that begin with a period (\(aq.\(aq) are reserved to the implementation.
fr: Les trousseaux de clés avec des descriptions (nom) commençant par un point (.) sont réservées à l’implémentation.

note: type: Plain text
en: This is a general-purpose key type.  The key is kept entirely within kernel memory.  The payload may be read and updated by user-space applications.
fr: Il s’agit d’un type de clé générique. La clé est entièrement conservée dans la mémoire du noyau. La charge utile peut être lue et mise à jour par des applications de l’espace utilisateur.

note: type: Plain text
en: The payload for keys of this type is a blob of arbitrary data of up to 32,767 bytes.
fr: La charge utile des clés de ce type est un objet binaire (blob) de données arbitraires pouvant contenir 32 767 octets.

note: type: Plain text
en: The description may be any valid string, though it is preferred that it start with a colon-delimited prefix representing the service to which the key is of interest (for instance I<"afs:mykey">).
fr: La description peut être n’importe quelle chaîne autorisée, bien qu’il est préférable qu’elle commence par un préfixe délimité par un deux-points représentant le service auquel la clé est destinée (par exemple, « I<afs:mykey> »).

note: type: TP
en: I<"logon"> (since Linux 3.3)
fr: I<"logon"> (depuis Linux 3.3)

note: commit 9f6ed2ca257fa8650b876377833e6f14e272848b type: Plain text
en: This key type is essentially the same as I<"user">, but it does not provide reading (i.e., the B<keyctl>(2)  B<KEYCTL_READ> operation), meaning that the key payload is never visible from user space.  This is suitable for storing username-password pairs that should not be readable from user space.
fr: Ce type de clé est fondamentalement identique à « I<user> », mais ne permet pas la lecture (c’est-à-dire l’opération B<KEYCTL_READ> de B<keyctl>(2)), signifiant que la charge utile n’est jamais visible à partir de l’espace utilisateur. Cela est adapté au stockage de paires nom d’utilisateur/mot de passe qui ne doivent pas être lisibles à partir de l’espace utilisateur.

note: type: Plain text
en: The description of a I<"logon"> key I<must> start with a non-empty colon-delimited prefix whose purpose is to identify the service to which the key belongs.  (Note that this differs from keys of the I<"user"> type, where the inclusion of a prefix is recommended but is not enforced.)
fr: La description de la clé « I<logon> » I<doit> débutée par un préfixe non vide délimité par un deux-points dont le but est d’identifier le service auquel la clé appartient. Il est à remarquer que cela diffère du type de clé « I<user> », ou l’incorporation du préfixe est recommandée mais pas obligée.

note: type: TP
en: I<"big_key"> (since Linux 3.13)
fr: I<"big_key"> (depuis Linux 3.13)

note: commit ab3c3587f8cda9083209a61dbe3a4407d3cada10 type: Plain text
en: This key type is similar to the I<"user"> key type, but it may hold a payload of up to 1\ MiB in size.  This key type is useful for purposes such as holding Kerberos ticket caches.
fr: Ce type de clé est semblable au type « I<user> » de clé, mais il peut contenir une charge utile de taille 1\ MiB. Ce type de clé est utile pour, par exemple, contenir des caches de ticket Kerberos.

note: commit 13100a72f40f5748a04017e0ab3df4cf27c809ef type: Plain text
en: The payload data may be stored in a tmpfs filesystem, rather than in kernel memory, if the data size exceeds the overhead of storing the data in the filesystem.  (Storing the data in a filesystem requires filesystem structures to be allocated in the kernel.  The size of these structures determines the size threshold above which the tmpfs storage method is used.)  Since Linux 4.8, the payload data is encrypted when stored in tmpfs, thereby preventing it from being written unencrypted into swap space.
fr: Les données de la charge utile peuvent être stockées dans un système de fichiers tmpfs, plutôt que dans la mémoire du noyau si la taille des données excède la surcharge due au stockage des données dans le système de fichiers. Stocker les données dans un système de fichiers nécessite que des structures de système de fichiers soient allouées dans le noyau. La taille de ces structures détermine le seuil au-dessus duquel la méthode tmpfs de stockage est utilisée. Depuis Linux 4.8, les données de la charge utile sont chiffrées lorsqu’elles sont stockées en tmpfs, par conséquent empêchant qu’elles soient écrites dans l’espace d’échange sans être chiffrées.

note: type: Plain text
en: There are more specialized key types available also, but they aren't discussed here because they aren't intended for normal user-space use.
fr: Il existe aussi d’autres types de clé spécialisés, mais ne sont pas évoquées ici car elles ne sont pas destinées à une utilisation normale en espace utilisateur.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: Key type names that begin with a period (\(aq.\(aq) are reserved to the implementation.
fr: Les noms de type de clé qui commencent par un point (.) sont réservés à l’implémentation.

note: type: SS
en: Keyrings
fr: Trousseaux de clés

note: type: Plain text
en: As previously mentioned, keyrings are a special type of key that contain links to other keys (which may include other keyrings).  Keys may be linked to by multiple keyrings.  Keyrings may be considered as analogous to UNIX directories where each directory contains a set of hard links to files.
fr: Comme indiqué précédemment, les trousseaux de clés sont un type spécial de clé qui contient des liens vers d’autres clés (pouvant inclure d’autres trousseaux de clés). Les clés peuvent être liées à plusieurs trousseaux de clés. Les trousseaux de clés peuvent être considérées comme analogues à des répertoires UNIX où chaque répertoire contient un ensemble de liens physiques vers des fichiers.

note: type: Plain text
en: Various operations (system calls) may be applied only to keyrings:
fr: Différentes opérations (appels système) peuvent être appliquées seulement aux trousseaux de clés :

note: type: IP
en: Adding
fr: Ajout

note: type: Plain text
en: A key may be added to a keyring by system calls that create keys.  This prevents the new key from being immediately deleted when the system call releases its last reference to the key.
fr: Une clé peut être ajoutée dans un trousseau de clés par les appels système ayant créé les clés.

note: type: IP
en: Linking
fr: Liaison

note: type: Plain text
en: A link may be added to a keyring pointing to a key that is already known, provided this does not create a self-referential cycle.
fr: Un lien peut être ajouté à un trousseau de clés pointant vers une clé déjà connue. Cela ne crée pas un cycle d’auto-référencement.

note: type: IP
en: Unlinking
fr: Déliaison

note: type: Plain text
en: A link may be removed from a keyring.  When the last link to a key is removed, that key will be scheduled for deletion by the garbage collector.
fr: Un lien peut être supprimé d’un trousseau de clés. Quand le dernier lien vers une clé est supprimé, cette clé sera programmée pour être collectée par le ramasse-miettes.

note: type: IP
en: Clearing
fr: Effacement

note: type: Plain text
en: All the links may be removed from a keyring.
fr: Tous les liens peuvent être supprimés d’un trousseau de clés.

note: type: IP
en: Searching
fr: Recherche

note: type: Plain text
en: A keyring may be considered the root of a tree or subtree in which keyrings form the branches and non-keyrings the leaves.  This tree may be searched for a key matching a particular type and description.
fr: Un trousseau de clés peut être considéré comme la racine d’un arbre ou d’un sous-arbre dans lesquels les trousseaux de clés forment les branches et le reste les feuilles. Cet arbre peut être parcouru pour rechercher une clé d’une description ou d’un type particulier.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: See B<keyctl_clear>(3), B<keyctl_link>(3), B<keyctl_search>(3), and B<keyctl_unlink>(3)  for more information.
fr: Consultez B<keyctl_clear>(3), B<keyctl_link>(3), B<keyctl_search>(3) et B<keyctl_unlink>(3) pour davantage d’informations.

note: type: SS
en: Anchoring keys
fr: Clés d’ancrage

note: type: Plain text
en: To prevent a key from being garbage collected, it must be anchored to keep its reference count elevated when it is not in active use by the kernel.
fr: Pour empêcher une clé d’être collectée par le ramasse-miettes, elle doit être ancrée pour conserver son comptage de références en cours lorsqu’elle n’est pas utilisée activement par le noyau.

note: type: Plain text
en: Keyrings are used to anchor other keys: each link is a reference on a key.  Note that keyrings themselves are just keys and are also subject to the same anchoring requirement to prevent them being garbage collected.
fr: Les trousseaux de clés sont utilisés pour ancrer d’autres clés. Chaque lien est une référence dans la clé. Il est à remarquer que les trousseaux de clés eux-mêmes sont juste des clés et sont aussi sujets à la même nécessité d’ancrage pour empêcher qu’ils soient collectés par le ramasse-miettes.

note: type: Plain text
en: The kernel makes available a number of anchor keyrings.  Note that some of these keyrings will be created only when first accessed.
fr: Le noyau propose un certain nombre de trousseaux de clés d’ancrage. Il est à remarquer que certains de ces trousseaux de clés seront créés seulement lors de leur première accession.

note: type: TP
en: Process keyrings
fr: Trousseaux de clés de processus

note: type: Plain text
en: Process credentials themselves reference keyrings with specific semantics.  These keyrings are pinned as long as the set of credentials exists, which is usually as long as the process exists.
fr: Les identifiants de processus eux-mêmes référencent les trousseaux de clés avec des sémantiques spécifiques. Ces trousseaux de clés sont attachés aussi longtemps que l’ensemble des identifiants existe, ce qui veut dire habituellement aussi longtemps que le processus existe.

note: type: Plain text
en: There are three keyrings with different inheritance/sharing rules: the B<session-keyring>(7)  (inherited and shared by all child processes), the B<process-keyring>(7)  (shared by all threads in a process) and the B<thread-keyring>(7)  (specific to a particular thread).
fr: Il existe trois trousseaux de clés avec des règles d’héritage et de partage différentes : B<session-keyring>(7) (héritage et partage par tous les processus enfant), B<process-keyring>(7) (partage par tous les threads dans un processus) et B<thread-keyring>(7) (spécifique à un thread particulier).

note: type: Plain text
en: As an alternative to using the actual keyring IDs, in calls to B<add_key>(2), B<keyctl>(2), and B<request_key>(2), the special keyring values B<KEY_SPEC_SESSION_KEYRING>, B<KEY_SPEC_PROCESS_KEYRING>, and B<KEY_SPEC_THREAD_KEYRING> can be used to refer to the caller's own instances of these keyrings.
fr: Comme alternative à l’utilisation des identifiants réels de trousseau de clés, dans les appels à B<add_key>(2), B<keyctl>(2) et B<request_key>(2), les valeurs spéciales de trousseau de clés B<KEY_SPEC_SESSION_KEYRING>, B<KEY_SPEC_PROCESS_KEYRING> et B<KEY_SPEC_THREAD_KEYRING> peuvent être utilisées comme références aux propres instances de l’appelant de ces trousseaux de clés.

note: type: TP
en: User keyrings
fr: Trousseau de clés utilisateur

note: type: Plain text
en: Each UID known to the kernel has a record that contains two keyrings: the B<user-keyring>(7)  and the B<user-session-keyring>(7).  These exist for as long as the UID record in the kernel exists.
fr: Chaque UID connu du noyau possède un enregistrement qui contient deux trousseaux de clés : B<user-keyring>(7) et B<user-session-keyring>(7). Ceux-ci existent aussi longtemps que l’enregistrement de l’UID existe dans le noyau.

note: type: Plain text
en: As an alternative to using the actual keyring IDs, in calls to B<add_key>(2), B<keyctl>(2), and B<request_key>(2), the special keyring values B<KEY_SPEC_USER_KEYRING> and B<KEY_SPEC_USER_SESSION_KEYRING> can be used to refer to the caller's own instances of these keyrings.
fr: Comme alternative à l’utilisation des identifiants réels de trousseau de clés, dans les appels à B<add_key>(2), B<keyctl>(2) et B<request_key>(2), les valeurs spéciales de trousseau de clés B<KEY_SPEC_USER_KEYRING> et B<KEY_SPEC_USER_SESSION_KEYRING> peuvent être utilisées comme références aux propres instances de l’appelant de ces trousseaux de clés.

note: type: Plain text
en: A link to the user keyring is placed in a new session keyring by B<pam_keyinit>(8)  when a new login session is initiated.
fr: Un lien vers le trousseau de clés utilisateur est placé dans le nouveau trousseau de clés de session par B<pam_keyinit>(8) quand une nouvelle session de connexion est initiée.

note: type: TP
en: Persistent keyrings
fr: Trousseaux de clés persistants

note: type: Plain text
en: There is a B<persistent-keyring>(7)  available to each UID known to the system.  It may persist beyond the life of the UID record previously mentioned, but has an expiration time set such that it is automatically cleaned up after a set time.  The persistent keyring permits, for example, B<cron>(8)  scripts to use credentials that are left in the persistent keyring after the user logs out.
fr: Il existe un B<persistent-keyring>(7) disponible pour chaque UID connu du système. Il peut persister au-delà de la durée de l’enregistrement UID précédemment mentionné, mais possède un ensemble de délais d’expiration de telle façon qu’il soit automatiquement nettoyé après un temps défini. Les trousseaux de clés persistants permettent, par exemple, aux scripts B<cron>(8) d’utiliser les identifiants laissés dans le trousseau de clés persistent après la déconnexion de l’utilisateur.

note: type: Plain text
en: Note that the expiration time of the persistent keyring is reset every time the persistent key is requested.
fr: Il est à remarquer que le délai d’expiration du trousseau de clés persistent est réinitialisé à chaque requête du trousseau de clés persistent.

note: type: TP
en: Special keyrings
fr: Trousseaux de clés spéciaux

note: type: Plain text
en: There are special keyrings owned by the kernel that can anchor keys for special purposes.  An example of this is the I<system keyring> used for holding encryption keys for module signature verification.
fr: Des trousseaux de clés spéciaux existent possédés par le noyau qui peuvent ancrer des clés pour des buts spéciaux. Un exemple de cela est le I<trousseau de clés système> utilisé pour contenir les clés de chiffrement pour la vérification de signature des modèles.

note: type: Plain text
en: These special keyrings are usually closed to direct alteration by user space.
fr: Ces trousseaux de clés spéciaux sont habituellement fermés à une altération directe par l’espace utilisateur.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: An originally planned "group keyring", for storing keys associated with each GID known to the kernel, is not so far implemented, is unlikely to be implemented.  Nevertheless, the constant B<KEY_SPEC_GROUP_KEYRING> has been defined for this keyring.
fr: Un « trousseau de clés groupe », originellement prévu pour stocker des clés associées avec chaque GID connu du noyau, n’est pas encore implémenté et vraisemblablement ne le sera jamais. Néanmoins, la constante B<KEY_SPEC_GROUP_KEYRING> a été définie pour ce trousseau de clés.

note: type: Plain text
en: The concept of possession is important to understanding the keyrings security model.  Whether a thread possesses a key is determined by the following rules:
fr: Le concept de possession est important pour comprendre le modèle de sécurité des trousseaux de clés. La possession par un thread d’une clé est déterminée par les règles suivantes :

note: type: Plain text
en: Any key or keyring that does not grant I<search> permission to the caller is ignored in all the following rules.
fr: Toute clé ou tout trousseau qui n’accorde pas la permission de I<recherche> à l’appelant sont ignorés dans toutes les règles qui suivent.

note: type: Plain text
en: A thread possesses its B<session-keyring>(7), B<process-keyring>(7), and B<thread-keyring>(7)  directly because those keyrings are referred to by its credentials.
fr: Un thread possède ses B<session-keyring>(7), B<process-keyring>(7) et B<thread-keyring>(7) directement car ces trousseaux de clés sont référencés par ses identifiants.

note: type: Plain text
en: If a keyring is possessed, then any key it links to is also possessed.
fr: Si un trousseau de clés est possédé, alors toute clé liée est aussi possédée

note: type: Plain text
en: If any key a keyring links to is itself a keyring, then rule (3) applies recursively.
fr: Si n’importe quelle clé est reliée à un trousseau de clés, alors la règle (3) s’applique.

note: type: Plain text
en: If a process is upcalled from the kernel to instantiate a key (see B<request_key>(2)), then it also possesses the requester's keyrings as in rule (1) as if it were the requester.
fr: Si le noyau fait un appel montant de processus pour instancier une clé (consultez B<request_key>(2)), alors il possède aussi les trousseaux de clés du requérant comme dans la règle (1) comme s’il était le requérant.

note: type: Plain text
en: Note that possession is not a fundamental property of a key, but must rather be calculated each time the key is needed.
fr: La possession n’est pas une propriété fondamentale de la clé, mais doit plutôt être calculée à chaque besoin de la clé.

note: type: Plain text
en: Possession is designed to allow set-user-ID programs run from, say a user's shell to access the user's keys.  Granting permissions to the key possessor while denying them to the key owner and group allows the prevention of access to keys on the basis of UID and GID matches.
fr: La possession est conçue pour permettre l’exécution de programmes set-user-ID à partir, par exemple, d’un interpréteur de commandes d’utilisateur pour accéder aux clés de l’utilisateur. Accorder le permission au possesseur de la clé tout en la refusant au propriétaire et au groupe de la clé permet d’empêcher l’accès à la clé sur la base de correspondance D’UID ou GID.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: When it creates the session keyring, B<pam_keyinit>(8)  adds a link to the B<user-keyring>(7), thus making the user keyring and anything it contains possessed by default.
fr: Lorsqu’il crée un trousseau de clés de session, B<pam_keyinit>(8) ajoute un lien à B<user-keyring>(7), par conséquent faisant que le trousseau de clés d’utilisateur et tout ce qu’il contient sont possédés par défaut.

note: type: Plain text
en: Each key has the following security-related attributes:
fr: Chaque clé possède les attributs relatifs à la sécurité suivants :

note: type: IP
en: *
fr: –

note: type: Plain text
en: The owning user ID
fr: l’ID de l’utilisateur propriétaire ;

note: type: Plain text
en: The ID of a group that is permitted to access the key
fr: l’ID du groupe autorisé à accéder à la clé ;

note: type: Plain text
en: A security label
fr: une étiquette de sécurité ;

note: type: Plain text
en: A permissions mask
fr: un masque de permissions.

note: type: Plain text
en: The permissions mask contains four sets of rights.  The first three sets are mutually exclusive.  One and only one will be in force for a particular access check.  In order of descending priority, these three sets are:
fr: Le masque de permissions contient quatre ensembles de droits. Les trois premiers ensembles sont mutuellement exclusifs. Un et seulement un ensemble sera effectif pour une vérification particulière d’accès. Dans l’ordre décroissant de priorité, ces trois ensembles sont :

note: type: Plain text
en: The set specifies the rights granted if the key's user ID matches the caller's filesystem user ID.
fr: Cet ensemble indique les droits accordés si l’ID utilisateur de clé correspond à l’ID utilisateur de système de fichiers de l’appelant.

note: type: Plain text
en: The set specifies the rights granted if the user ID didn't match and the key's group ID matches the caller's filesystem GID or one of the caller's supplementary group IDs.
fr: Cet ensemble indique les droits accordés si l’ID utilisateur ne correspond pas et que l’ID groupe de clé correspond au GID du système de fichiers de l’appelant ou à un de ses ID groupe supplémentaires.

note: type: Plain text
en: The set specifies the rights granted if neither the key's user ID nor group ID matched.
fr: Cet ensemble indique les droits accordés si ni l’ID utilisateur ni l’Id groupe de la clé ne correspondent.

note: type: Plain text
en: The fourth set of rights is:
fr: Le quatrième ensemble de droits est :

note: type: Plain text
en: The set specifies the rights granted if a key is determined to be possessed by the caller.
fr: Cet ensemble indique les droits accordés s’il est établi que l’appelant possède la clé.

note: type: Plain text
en: The complete set of rights for a key is the union of whichever of the first three sets is applicable plus the fourth set if the key is possessed.
fr: L’ensemble complet des droits pour une clé est l’union de tout ce qui est applicable des trois premiers ensembles et du quatrième ensemble si la clé est possédée.

note: type: Plain text
en: The set of rights that may be granted in each of the four masks is as follows:
fr: L’ensemble de droits qui peuvent être accordés dans chacun des quatre masques est comme suit :

note: type: Plain text
en: The attributes of the key may be read.  This includes the type, description, and access rights (excluding the security label).
fr: Les attributs de la clé peuvent être lus. Cela comprend le type, la description et les droits d’accès (à l’exclusion de l’étiquette de sécurité).

note: type: Plain text
en: For a key: the payload of the key may be read.  For a keyring: the list of serial numbers (keys) to which the keyring has links may be read.
fr: Pour une clé, sa charge utile peut être lue, pour un trousseau de clés, la liste des numéros de série (clés) auxquels le trousseau de clés est lié peut être lue.

note: type: Plain text
en: The payload of the key may be updated and the key may be revoked.  For a keyring, links may be added to or removed from the keyring, and the keyring may be cleared completely (all links are removed),
fr: La charge utile de la clé peut être mise à jour et la clé peut être révoquée. Pour un trousseau de clés, des liens peuvent y être ajoutés ou retirés et le trousseau de clés peut être complètement effacé (tous les liens sont retirés).

note: type: Plain text
en: For a key (or a keyring): the key may be found by a search.  For a keyring: keys and keyrings that are linked to by the keyring may be searched.
fr: Pour une clé (ou un trousseau de clés), la clé peut être trouvée par une recherche. Pour un trousseau de clés, les clés ou trousseaux de clés liés peuvent être retrouvés.

note: type: Plain text
en: Links may be created from keyrings to the key.  The initial link to a key that is established when the key is created doesn't require this permission.
fr: Des liens peuvent être créés des trousseaux de clés vers la clé. Le lien initial vers une clé qui est établi quand la clé est créée n’a nul besoin de cette permission.

note: type: Plain text
en: The ownership details and security label of the key may be changed, the key's expiration time may be set, and the key may be revoked.
fr: Les détails de possession et l’étiquette de sécurité de la clé peuvent être modifiés, le délai d’expiration de la clé peut être réglé et la clé peut être révoquée.

note: type: Plain text
en: In addition to access rights, any active Linux Security Module (LSM) may prevent access to a key if its policy so dictates.  A key may be given a security label or other attribute by the LSM; this label is retrievable via B<keyctl_get_security>(3).
fr: En plus des droits d’accès, tout module de sécurité de Linux (LSM) peut empêcher l’accès à une clé si sa politique l’indique. Une clé peut recevoir une étiquette de sécurité ou un autre attribut par le LSM. Cette étiquette est retrouvable à l’aide de B<keyctl_get_security>(3).

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: See B<keyctl_chown>(3), B<keyctl_describe>(3), B<keyctl_get_security>(3), B<keyctl_setperm>(3), and B<selinux>(8)  for more information.
fr: Consultez B<keyctl_chown>(3), B<keyctl_describe>(3), B<keyctl_get_security>(3), B<keyctl_setperm>(3) et B<selinux>(8) pour davantage d’informations.

note: type: SS
en: Searching for keys
fr: Recherche de clés

note: type: Plain text
en: One of the key features of the Linux key-management facility is the ability to find a key that a process is retaining.  The B<request_key>(2)  system call is the primary point of access for user-space applications to find a key.  (Internally, the kernel has something similar available for use by internal components that make use of keys.)
fr: Une des caractéristiques principales de la fonctionnalité de gestion de clés de Linux est la possibilité de trouver la clé qu’un processus conserve. L’appel système B<request_key>(2) est le premier point d’accès pour les applications en espace utilisateur pour trouver la clé. En interne, le noyau a quelque chose de similaire disponible pour une utilisation par les composants internes qui permet l’utilisation de clés.

note: type: Plain text
en: The search algorithm works as follows:
fr: L’algorithme de recherche fonctionne comme suit :

note: type: Plain text
en: The process keyrings are searched in the following order: the thread B<thread-keyring>(7)  if it exists, the B<process-keyring>(7)  if it exists, and then either the B<session-keyring>(7)  if it exists or the B<user-session-keyring>(7)  if that exists.
fr: Les trousseaux de clés des processus sont recherchés dans l’ordre suivant : le thread B<thread-keyring>(7) s’il existe, le B<process-keyring>(7) s’il existe et ensuite soit le B<session-keyring>(7) s’il existe ou le B<user-session-keyring>(7) s’il existe.

note: type: Plain text
en: If the caller was a process that was invoked by the B<request_key>(2)  upcall mechanism, then the keyrings of the original caller of B<request_key>(2)  will be searched as well.
fr: Si l’appelant était un processus invoqué par le mécanisme d’appel montant B<request_key>(2), alors les trousseaux de clés de l’appelant originel de B<request_key>(2) seront aussi recherchés.

note: type: Plain text
en: The search of a keyring tree is in breadth-first order: each keyring is searched first for a match, then the keyrings referred to by that keyring are searched.
fr: La recherche dans l’arbre des trousseaux est faite en largeur : chaque trousseau de clés est d’abord parcouru pour une correspondance puis les trousseaux de clés référencés par ce trousseau sont parcourus.

note: type: Plain text
en: If a matching key is found that is valid, then the search terminates and that key is returned.
fr: Si une clé valable est trouvée, alors la recherche se termine et cette clé est renvoyée.

note: type: Plain text
en: If a matching key is found that has an error state attached, that error state is noted and the search continues.
fr: Si une clé correspondante est trouvée à laquelle est attaché un état d’erreur, cet état d’erreur est noté et la recherche continue.

note: type: Plain text
en: If no valid matching key is found, then the first noted error state is returned; otherwise, an B<ENOKEY> error is returned.
fr: Si aucune clé valable n’est trouvée, alors le premier état d’erreur est renvoyé. Autrement une erreur B<ENOKEY> est renvoyée.

note: type: Plain text
en: It is also possible to search a specific keyring, in which case only steps (3) to (6) apply.
fr: Il est aussi possible de rechercher une clé particulière auquel cas seules les étapes (3) à (6) s’appliquent.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: See B<request_key>(2)  and B<keyctl_search>(3)  for more information.
fr: Consultez B<request_key>(2) et B<keyctl_search>(3) pour davantage d’informations.

note: type: SS
en: On-demand key creation
fr: Création à la demande de clé

note: type: Plain text
en: If a key cannot be found, B<request_key>(2)  will, if given a I<callout_info> argument, create a new key and then upcall to user space to instantiate the key.  This allows keys to be created on an as-needed basis.
fr: Si une clé ne peut être trouvée, B<request_key>(2) créera, si un argument I<callout_info> est fourni, une nouvelle clé et puis un appel montant dans l’espace utilisateur instanciera la clé. Cela permet de créer des clés selon les besoins.

note: type: Plain text
en: Typically, this will involve the kernel creating a new process that executes the B<request-key>(8)  program, which will then execute the appropriate handler based on its configuration.
fr: Classiquement, cela impliquera la création d’un nouveau processus par le noyau, qui exécutera le programme B<request-key>(8), qui alors exécutera le gestionnaire approprié basé sur sa configuration.

en: The handler is passed a special authorization key that allows it and only it to instantiate the new key.  This is also used to permit searches performed by the handler program to also search the requester's keyrings.
fr: Une clé d’autorisation spéciale est passée au noyau qui lui permet et seulement lui d’instancier la nouvelle clé. Cela est aussi utilisé pour permettre des recherches réalisées par le gestionnaire de programme pour aussi rechercher les trousseaux de clés du requérant.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: See B<request_key>(2), B<keyctl_assume_authority>(3), B<keyctl_instantiate>(3), B<keyctl_negate>(3), B<keyctl_reject>(3), B<request-key>(8), and B<request-key.conf>(5)  for more information.
fr: Consultez B<request_key>(2), B<keyctl_assume_authority>(3), B<keyctl_instantiate>(3), B<keyctl_negate>(3), B<keyctl_reject>(3), B<request-key>(8) et B<request-key.conf>(5) pour davantage d’informations.

note: type: SS
en: /proc files
fr: Fichiers /proc

note: type: Plain text
en: The kernel provides various I</proc> files that expose information about keys or define limits on key usage.
fr: Le noyau fournit divers fichiers I</proc> qui exposent les informations concernant les clés ou qui définissent les limites d’utilisation des clés.

note: type: TP
en: I</proc/keys> (since Linux 2.6.10)
fr: I</proc/keys> (depuis Linux 2.6.10)

note: David Howells, Dec 2016 linux-man@: This [The thread need not possess the key for it to be visible in this file.] is correct.  See proc_keys_show() in security/keys/proc.c: rc = key_task_permission(key_ref, ctx.cred, KEY_NEED_VIEW); if (rc < 0) return 0; Possibly it shouldn't be, but for now it is. 
en: This file exposes a list of the keys for which the reading thread has I<view> permission, providing various information about each key.  The thread need not possess the key for it to be visible in this file.
fr: Ce fichier expose une liste de clés pour laquelle le thread lecteur possède la permission I<view>, fournissant diverses informations à propos de chaque clé.

note: type: Plain text
en: The only keys included in the list are those that grant I<view> permission to the reading process (regardless of whether or not it possesses them).  LSM security checks are still performed, and may filter out further keys that the process is not authorized to view.
fr: Les seules clés incluses dans la liste sont celles qui accordent la permission I<view> au processus lecteur (indépendamment du fait qu’il les possède ou non). Les vérifications de sécurité LSM sont toujours réalisées et peuvent supprimer par filtrage d’autres clés que le processus n’est pas autorisé à voir.

note: type: Plain text
en: An example of the data that one might see in this file (with the columns numbered for easy reference below)  is the following:
fr: Un exemple de données pouvant être vues dans ce fichier (avec un numérotage des colonnes pour une référence facile dans les explications) est ce qui suit :

note: type: Plain text
en: The fields shown in each line of this file are as follows:
fr: Les champs affichés dans chaque ligne du fichier sont les suivants :

note: type: Plain text
en: The ID (serial number) of the key, expressed in hexadecimal.
fr: L’Id (numéro de série) de la clé exprimé en hexadécimal.

note: type: TP
en: Flags (2)
fr: Indicateurs (2)

note: type: Plain text
en: A set of flags describing the state of the key:
fr: Un ensemble d’indicateurs décrivant l’état de la clé :

note: KEY_FLAG_INSTANTIATED type: Plain text
en: The key has been instantiated.
fr: La clé a été instanciée.

note: KEY_FLAG_REVOKED type: Plain text
en: The key has been revoked.
fr: La clé a été révoquée.

note: KEY_FLAG_DEAD unregister_key_type() in the kernel source type: Plain text
en: The key is dead (i.e., the key type has been unregistered).  (A key may be briefly in this state during garbage collection.)
fr: La clé est morte (c’est-à-dire que le type de clé n’a pas été enregistré). Une clé peut être brièvement dans cet état lors du collectage par le ramasse-miettes.

note: KEY_FLAG_IN_QUOTA type: Plain text
en: The key contributes to the user's quota.
fr: La clé contribue au quota de l’utilisateur.

note: KEY_FLAG_USER_CONSTRUCT type: Plain text
en: The key is under construction via a callback to user space; see B<request-key>(2).
fr: La clé est en cours de construction à l’aide d’une fonction de rappel dans l’espace utilisateur. Consultez B<request-key>(2).

note: KEY_FLAG_NEGATIVE type: Plain text
en: The key is negatively instantiated.
fr: La clé est instanciée négativement.

note: KEY_FLAG_INVALIDATED type: Plain text
en: The key has been invalidated.
fr: La clé a été invalidée.

note: type: TP
en: Usage (3)
fr: Utilisation (3)

note: type: Plain text
en: This is a count of the number of kernel credential structures that are pinning the key (approximately: the number of threads and open file references that refer to this key).
fr: C’est un comptage du nombre de structures d’identifiant qui épinglent la clé (approximativement, le nombre de références de threads et de fichiers ouverts qui se réfèrent à cette clé).

note: type: TP
en: Timeout (4)
fr: Durée (4)

note: type: Plain text
en: The amount of time until the key will expire, expressed in human-readable form (weeks, days, hours, minutes, and seconds).  The string I<perm> here means that the key is permanent (no timeout).  The string I<expd> means that the key has already expired, but has not yet been garbage collected.
fr: Le délai avant que la clé n’expire, exprimé sous forme compréhensible (semaines, jours, heures, minutes et secondes). La chaîne I<perm> signifie ici que la clé est permanente (aucun délai). La chaîne I<expd> signifie que la clé a déjà expirée, mais n’a pas été collectée par le ramasse-miettes.

note: type: Plain text
en: The key permissions, expressed as four hexadecimal bytes containing, from left to right, the possessor, user, group, and other permissions.  Within each byte, the permission bits are as follows:
fr: Les permissions de clé, exprimées sous forme de quatre octets hexadécimaux contenant, de gauche à droite, le possesseur, l’utilisateur, le groupe et les autres permissions. À l’intérieur de chaque octet, les bits de permission sont comme suit :

note: type: Plain text
en: The user ID of the key owner.
fr: L’ID utilisateur du possesseur de la clé.

note: type: Plain text
en: The group ID of the key.  The value -1 here means that the key has no group ID; this can occur in certain circumstances for keys created by the kernel.
fr: L’ID de groupe de la clé. La valeur -1 signifie ici que la clé n’a pas d’ID de groupe. Cela peut se produire dans certaines circonstances pour des clés créées par le noyau.

note: type: Plain text
en: The key type (user, keyring, etc.)
fr: Le type de clé (utilisateur, trousseau de clés, etc.)

note: type: Plain text
en: The key description (name).  This field contains descriptive information about the key.  For most key types, it has the form
fr: La description de la clé (nom). Ce champ contient une information descriptive à propos de la clé. Pour la plupart des types de clé, elle a la forme

note: type: Plain text
en:      name[: extra-info]
fr:      nom[: extra-info]

note: type: Plain text
en: The I<name> subfield is the key's description (name).  The optional I<extra-info> field provides some further information about the key.  The information that appears here depends on the key type, as follows:
fr: Le sous-champ I<nom> est la description de la clé (nom). Le champ facultatif I<extra-info> fournit quelques autres informations à propos de la clé. Les informations qui apparaissent comme suit dépendent du type de clé :

note: type: TP
en: I<"user"> and I<"logon">
fr: I<"user"> et I<"logon">

note: type: Plain text
en: The size in bytes of the key payload (expressed in decimal).
fr: La taille en octets de la charge utile de la clé (exprimée en décimal).

note: type: Plain text
en: The number of keys linked to the keyring, or the string I<empty> if there are no keys linked to the keyring.
fr: Le nombre de clés liées au trousseau de clés ou la chaîne B<empty> s’il n’existe aucune clé liée au trousseau.

note: type: Plain text
en: The payload size in bytes, followed either by the string I<[file]>, if the key payload exceeds the threshold that means that the payload is stored in a (swappable)  B<tmpfs>(5)  filesystem, or otherwise the string I<[buff]>, indicating that the key is small enough to reside in kernel memory.
fr: La taille de la charge utile en octets, suivie soit par la chaîne I<[file]> si la charge utile de la clé excède le seuil signifiant que la charge utile est stockée dans un système de fichiers B<tmpfs>(5) (swappable), ou autrement la chaîne I<[buff]> indiquant que la clé est suffisamment petite pour résider dans la mémoire du noyau.

note: type: Plain text
en: For the I<".request_key_auth"> key type (authorization key; see B<request_key>(2)), the description field has the form shown in the following example:
fr: Pour le type de clé « I<.request_key_auth> » (clé d’autorisation, consultez B<request_key>(2)), le champ de description a la forme montrée dans l’exemple suivant :

note: type: Plain text
en: The three subfields are as follows:
fr: Les trois sous-champs sont comme suit :

note: type: Plain text
en: The hexadecimal ID of the key being instantiated in the requesting program.
fr: L’Id hexadécimal de la clé en cours d’instanciation dans le programme requérant.

note: type: Plain text
en: The PID of the requesting program.
fr: Le PID du programme requérant.

note: type: Plain text
en: The length of the callout data with which the requested key should be instantiated (i.e., the length of the payload associated with the authorization key).
fr: La taille des annotations avec lesquelles la clé demandée devrait être instanciée (c’est-à-dire la taille de la charge utile associée avec la clé d’autorisation).

note: type: TP
en: I</proc/key-users> (since Linux 2.6.10)
fr: I</proc/key-users> (depuis Linux 2.6.10)

note: type: Plain text
en: This file lists various information for each user ID that has at least one key on the system.  An example of the data that one might see in this file is the following:
fr: Ce fichier liste diverses informations pour chaque ID utilisateur qui possède au moins une clé dans le système. Un exemple des données visibles dans ce fichier est le suivant :

note: type: Plain text
en: The fields shown in each line are as follows:
fr: Les champs affichés dans chaque ligne sont les suivants :

note: type: Plain text
en: The user ID.
fr: L’ID utilisateur.

note: type: Plain text
en: This is a kernel-internal usage count for the kernel structure used to record key users.
fr: Il s’agit d’un comptage d’utilisation interne au noyau pour la structure utilisée pour enregistrer les utilisateurs de clé.

note: type: Plain text
en: The total number of keys owned by the user, and the number of those keys that have been instantiated.
fr: Le nombre total de clé possédées par l’utilisateur et le nombre de clés ayant été instanciées.

note: type: Plain text
en: The number of keys owned by the user, and the maximum number of keys that the user may own.
fr: Le nombre de clés possédées par l’utilisateur et le nombre maximal de clés que l’utilisateur peut posséder.

note: type: Plain text
en: The number of bytes consumed in payloads of the keys owned by this user, and the upper limit on the number of bytes in key payloads for that user.
fr: Le nombre de clés utilisées dans les charges utiles des clés possédées par l’utilisateur et la limite haute du nombre d’octets dans les charges utiles des clés pour cet utilisateur.

note: type: TP
en: I</proc/sys/kernel/keys/gc_delay> (since Linux 2.6.32)
fr: I</proc/sys/kernel/keys/gc_delay> (depuis Linux 2.6.32)

note: commit 5d135440faf7db8d566de0c6fab36b16cf9cfc3b type: Plain text
en: The value in this file specifies the interval, in seconds, after which revoked and expired keys will be garbage collected.  The purpose of having such an interval is so that there is a window of time where user space can see an error (respectively B<EKEYREVOKED> and B<EKEYEXPIRED>)  that indicates what happened to the key.
fr: La valeur dans ce fichier indique l’intervalle, en seconde, après lequel les clés révoquées ou expirées seront collectées par le ramasse-miettes. Le but d’un tel intervalle est qu’il existe une fenêtre temporelle pendant lequel l’espace utilisateur peut voir une erreur (respectivement B<EKEYREVOKED> et B<EKEYEXPIRED>) qui indique ce qui est arrivé à la clé.

note: type: Plain text
en: The default value in this file is 300 (i.e., 5 minutes).
fr: La valeur par défaut dans ce fichier est 300 (c’est-à-dire cinq minutes).

note: type: TP
en: I</proc/sys/kernel/keys/persistent_keyring_expiry> (since Linux 3.13)
fr: I</proc/sys/kernel/keys/persistent_keyring_expiry> (depuis Linux 3.13)

note: commit f36f8c75ae2e7d4da34f4c908cebdb4aa42c977e type: Plain text
en: This file defines an interval, in seconds, to which the persistent keyring's expiration timer is reset each time the keyring is accessed (via B<keyctl_get_persistent>(3)  or the B<keyctl>(2)  B<KEYCTL_GET_PERSISTENT> operation.)
fr: Ce fichier définit un intervalle, en seconde, après lequel le programmateur de durée de trousseau de clés persistent est réinitialisé chaque fois que le trousseau de clés est accédé (à l’aide de l’opération B<keyctl_get_persistent>(3) ou B<keyctl>(2) B<KEYCTL_GET_PERSISTENT>).

note: type: Plain text
en: The default value in this file is 259200 (i.e., 3 days).
fr: La valeur par défaut dans ce fichier est 259200 (c’est-à-dire trois jours).

note: type: Plain text
en: The following files (which are writable by privileged processes)  are used to enforce quotas on the number of keys and number of bytes of data that can be stored in key payloads:
fr: Les fichiers suivants (pouvant être modifiés par les processus privilégiés) sont utilisés pour imposer des quotas sur le nombre de clés et le nombre d’octets de données pouvant être stockés dans les charges utiles des clés :

note: type: TP
en: I</proc/sys/kernel/keys/maxbytes> (since Linux 2.6.26)
fr: I</proc/sys/kernel/keys/maxbytes> (depuis Linux 2.6.26)

note: commit 0b77f5bfb45c13e1e5142374f9d6ca75292252a4 Previously: KEYQUOTA_MAX_BYTES      10000 type: Plain text
en: This is the maximum number of bytes of data that a nonroot user can hold in the payloads of the keys owned by the user.
fr: C’est le nombre maximal d’octets de données que les utilisateurs normaux peuvent détenir dans les charges utiles des clés possédées par l’utilisateur.

note: type: Plain text
en: The default value in this file is 20,000.
fr: La valeur par défaut dans ce fichier est 20 000.

note: type: TP
en: I</proc/sys/kernel/keys/maxkeys> (since Linux 2.6.26)
fr: I</proc/sys/kernel/keys/maxkeys> (depuis Linux 2.6.26)

note: commit 0b77f5bfb45c13e1e5142374f9d6ca75292252a4 Previously: KEYQUOTA_MAX_KEYS       100 type: Plain text
en: This is the maximum number of keys that a nonroot user may own.
fr: C’est le nombre maximal de clés qu’un utilisateur normal peut posséder.

note: type: Plain text
en: The default value in this file is 200.
fr: La valeur par défaut dans ce fichier est 200.

note: type: TP
en: I</proc/sys/kernel/keys/root_maxbytes> (since Linux 2.6.26)
fr: I</proc/sys/kernel/keys/root_maxbytes> (depuis Linux 2.6.26)

note: type: Plain text
en: This is the maximum number of bytes of data that the root user (UID 0 in the root user namespace)  can hold in the payloads of the keys owned by root.
fr: C’est le nombre maximal d’octets de données que le superutilisateur (UID 0 dans l’espace de noms utilisateur racine) peut détenir dans les charges utiles des clés possédées par le superutilisateur.

note: 738c5d190f6540539a04baf36ce21d46b5da04bd commit 0b77f5bfb45c13e1e5142374f9d6ca75292252a4 type: Plain text
en: The default value in this file is 25,000,000 (20,000 before Linux 3.17).
fr: La valeur par défaut dans ce fichier est 25 000 000 (20 000 avant Linux 3.17).

note: type: TP
en: I</proc/sys/kernel/keys/root_maxkeys> (since Linux 2.6.26)
fr: I</proc/sys/kernel/keys/root_maxkeys> (depuis Linux 2.6.26)

note: commit 0b77f5bfb45c13e1e5142374f9d6ca75292252a4 type: Plain text
en: This is the maximum number of keys that the root user (UID 0 in the root user namespace)  may own.
fr: C’est le nombre maximal de clés que le superutilisateur (UID 0 dans l’espace de noms utilisateur racine) peut détenir.

note: 738c5d190f6540539a04baf36ce21d46b5da04bd type: Plain text
en: The default value in this file is 1,000,000 (200 before Linux 3.17).
fr: La valeur par défaut dans ce fichier est 1 000 000 (200 avant Linux 3.17).

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: With respect to keyrings, note that each link in a keyring consumes 4 bytes of the keyring payload.
fr: En ce qui concerne les trousseaux de clés, il est à remarquer que chaque lien dans un trousseau consomme quatre octets de la charge utile du trousseau.

note: type: SS
en: Users
fr: Utilisateurs

note: type: Plain text
en: The Linux key-management facility has a number of users and usages, but is not limited to those that already exist.
fr: La fonctionnalité de gestion de clés de Linux a un certain nombre d’utilisateurs et d’usages, mais n’est pas limitée à ce qui existe déjà.

note: type: Plain text
en: In-kernel users of this facility include:
fr: Les utilisateurs du noyau de cette fonctionnalité comprennent :

note: type: TP
en: Network filesystems - DNS
fr: Systèmes de fichiers réseau – DNS

note: type: Plain text
en: The kernel uses the upcall mechanism provided by the keys to upcall to user space to do DNS lookups and then to cache the results.
fr: Le noyau utilise le mécanisme d’appel montant fourni par les clés pour un appel montant dans l’espace utilisateur pour des recherches DNS et puis pour mettre en cache les résultats.

note: type: TP
en: AF_RXRPC and kAFS - Authentication
fr: AF_RXRPC et kAFS – Authentification

note: type: Plain text
en: The AF_RXRPC network protocol and the in-kernel AFS filesystem use keys to store the ticket needed to do secured or encrypted traffic.  These are then looked up by network operations on AF_RXRPC and filesystem operations on kAFS.
fr: Le protocole réseau AF_RXRPC et le système de fichiers AFS interne au noyau utilisent les clés pour enregistrer le ticket nécessaire pour un trafic sécurisé ou chiffré. Celles-ci sont recherchées par les opérations réseau lors d’opérations AF_RXRPC et de système de fichiers sur kAFS.

note: type: TP
en: NFS - User ID mapping
fr: NFS – Mappage d’ID utilisateur

note: type: Plain text
en: The NFS filesystem uses keys to store mappings of foreign user IDs to local user IDs.
fr: Le système de fichiers NFS utilise des clés pour stocker les mappages d’ID utilisateur étrangers à des ID utilisateur locaux.

note: type: TP
en: CIFS - Password
fr: CIFS – Mot de passe

note: type: Plain text
en: The CIFS filesystem uses keys to store passwords for accessing remote shares.
fr: Le système de fichiers CIFS utilise des clés pour stocker les mots de passe pour une accession à des partages distants.

note: type: TP
en: Module verification
fr: Vérification de module

note: type: Plain text
en: The kernel build process can be made to cryptographically sign modules.  That signature is then checked when a module is loaded.
fr: Le processus de construction du noyau peut être conduit pour une signature chiffrée des modules

note: type: Plain text
en: User-space users of this facility include:
fr: Les utilisateurs de l’espace utilisateur de cette fonctionnalité incluent :

note: type: TP
en: Kerberos key storage
fr: Stockage de clés Kerberos

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: The MIT Kerberos 5 facility (libkrb5) can use keys to store authentication tokens which can be made to be automatically cleaned up a set time after the user last uses them, but until then permits them to hang around after the user has logged out so that B<cron>(8)  scripts can use them.
fr: La fonctionnalité Kerberos 5 du MIT (libkrb5) peut utiliser des clés pour stocker les jetons d’authentification. Cela peut être fait pour automatiquement effacer une durée d’ensemble après que le dernier utilisateur l’ai utilisé, mais jusqu’à ce moment attendre que le dernier utilisateur soit déconnecté de façon que les scripts B<cron>(8) puissent les utiliser.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: The kernel source files I<Documentation/crypto/asymmetric-keys.txt> and under I<Documentation/security/keys> (or, before Linux 4.13, in the file I<Documentation/security/keys.txt>).
fr: Les fichiers de source du noyau I<Documentation/crypto/asymmetric-keys.txt> et dans I<Documentation/security/keys> (ou, avant Linux 4.13, dans le fichier I<Documentation/security/keys.txt>).

note: type: Plain text
en: This page is part of release 5.13 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.13 du projet I<man-pages> 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/.

note: type: TH
en: 2020-08-13
fr: 13 août 2020

note: type: Plain text
en: This page is part of release 5.10 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.10 du projet I<man-pages> 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/.

note: type: TH
en: 2017-09-15
fr: 15 septembre 2017

note: type: Plain text
en: The description of a I<"logon"> key I<muststart with a non-empty colon-delimited prefix whose purpose> is to identify the service to which the key belongs.  (Note that this differs from keys of the I<"user"> type, where the inclusion of a prefix is recommended but is not enforced.)
fr: La description de la clé I<logon> I<doit débuter par un préfixe non vide délimité par un deux-points> dont le but est d’identifier le service auquel la clé appartient. Il est à remarquer que cela diffère des clés du type « I<user> », où l’inclusion d’un préfixe est recommandée mais pas imposé.

note: type: Plain text
en: This page is part of release 4.16 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 4.16 du projet I<man-pages> 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/.
