1 .\" Copyright (C) 2016 Michael Kerrisk <mtk.manpages@gmail.com>
2 .\" and Copyright (C) 2016 Eugene Syromyatnikov <evgsyr@gmail.com>
3 .\" A very few fragments remain from an earlier version of this page
4 .\" written by David Howells (dhowells@redhat.com)
6 .\" SPDX-License-Identifier: Linux-man-pages-copyleft
8 .TH KEYCTL 2 2021-08-27 Linux "Linux Key Management Calls"
10 keyctl \- manipulate the kernel's key management facility
13 .RI ( libc ", " \-lc )
15 Alternatively, Linux Key Management Utilities
16 .RI ( libkeyutils ", " \-lkeyutils );
20 .BR "#include <linux/keyctl.h>" " /* Definition of " KEY* " constants */"
21 .BR "#include <sys/syscall.h>" " /* Definition of " SYS_* " constants */"
22 .B #include <unistd.h>
24 .BI "long syscall(SYS_keyctl, int " operation ", unsigned long " arg2 ,
25 .BI " unsigned long " arg3 ", unsigned long " arg4 ,
26 .BI " unsigned long " arg5 );
30 glibc provides no wrapper for
32 necessitating the use of
36 allows user-space programs to perform key manipulation.
38 The operation performed by
40 is determined by the value of the
43 Each of these operations is wrapped by the
45 library (provided by the
47 package) into individual functions (noted below)
48 to permit the compiler to check types.
50 The permitted values for
54 .BR KEYCTL_GET_KEYRING_ID " (since Linux 2.6.10)"
55 Map a special key ID to a real key ID for this process.
57 This operation looks up the special key whose ID is provided in
61 If the special key is found,
62 the ID of the corresponding real key is returned as the function result.
63 The following values may be specified in
67 .B KEY_SPEC_THREAD_KEYRING
68 This specifies the calling thread's thread-specific keyring.
70 .BR thread\-keyring (7).
72 .B KEY_SPEC_PROCESS_KEYRING
73 This specifies the caller's process-specific keyring.
75 .BR process\-keyring (7).
77 .B KEY_SPEC_SESSION_KEYRING
78 This specifies the caller's session-specific keyring.
80 .BR session\-keyring (7).
82 .B KEY_SPEC_USER_KEYRING
83 This specifies the caller's UID-specific keyring.
85 .BR user\-keyring (7).
87 .B KEY_SPEC_USER_SESSION_KEYRING
88 This specifies the caller's UID-session keyring.
90 .BR user\-session\-keyring (7).
92 .BR KEY_SPEC_REQKEY_AUTH_KEY " (since Linux 2.6.16)"
93 .\" commit b5f545c880a2a47947ba2118b2509644ab7a2969
94 This specifies the authorization key created by
96 and passed to the process it spawns to generate a key.
97 This key is available only in a
98 .BR request\-key (8)-style
99 program that was passed an authorization key by the kernel and
100 ceases to be available once the requested key has been instantiated; see
103 .BR KEY_SPEC_REQUESTOR_KEYRING " (since Linux 2.6.29)"
104 .\" commit 8bbf4976b59fc9fc2861e79cab7beb3f6d647640
105 This specifies the key ID for the
108 This keyring is available only in a
109 .BR request\-key (8)-style
110 program that was passed an authorization key by the kernel and
111 ceases to be available once the requested key has been instantiated; see
115 The behavior if the key specified in
117 does not exist depends on the value of
123 contains a nonzero value, then\(emif it is appropriate to do so
124 (e.g., when looking up the user, user-session, or session key)\(ema new key
125 is created and its real key ID returned as the function result.
126 .\" The keyctl_get_keyring_ID.3 page says that a new key
127 .\" "will be created *if it is appropriate to do so**. What is the
128 .\" determiner for appropriate?
129 .\" David Howells: Some special keys such as KEY_SPEC_REQKEY_AUTH_KEY
130 .\" wouldn't get created but user/user-session/session keyring would
132 Otherwise, the operation fails with the error
135 If a valid key ID is specified in
137 and the key exists, then this operation simply returns the key ID.
138 If the key does not exist, the call fails with error
143 permission on a keyring in order for it to be found.
151 This operation is exposed by
154 .BR keyctl_get_keyring_ID (3).
156 .BR KEYCTL_JOIN_SESSION_KEYRING " (since Linux 2.6.10)"
157 Replace the session keyring this process subscribes to with
158 a new session keyring.
159 .\" This may be useful in conjunction with some sort of
160 .\" session management framework that is employed by the application.
165 an anonymous keyring with the description "_ses" is created
166 and the process is subscribed to that keyring as its session keyring,
167 displacing the previous session keyring.
173 is treated as the description (name) of a keyring,
174 and the behavior is as follows:
177 If a keyring with a matching description exists,
178 the process will attempt to subscribe to that keyring
179 as its session keyring if possible;
180 if that is not possible, an error is returned.
181 In order to subscribe to the keyring,
184 permission on the keyring.
186 If a keyring with a matching description does not exist,
187 then a new keyring with the specified description is created,
188 and the process is subscribed to that keyring as its session keyring.
198 This operation is exposed by
201 .BR keyctl_join_session_keyring (3).
203 .BR KEYCTL_UPDATE " (since Linux 2.6.10)"
204 Update a key's data payload.
210 specifies the ID of the key to be updated.
215 points to the new payload and
219 contains the new payload size in bytes.
223 permission on the key specified and the key type must support updating.
225 A negatively instantiated key (see the description of
227 can be positively instantiated with this operation.
233 This operation is exposed by
236 .BR keyctl_update (3).
238 .BR KEYCTL_REVOKE " (since Linux 2.6.10)"
239 Revoke the key with the ID provided in
243 The key is scheduled for garbage collection;
244 it will no longer be findable,
245 and will be unavailable for further operations.
246 Further attempts to use the key will fail with the error
253 permission on the key.
254 .\" Keys with the KEY_FLAG_KEEP bit set cause an EPERM
255 .\" error for KEYCTL_REVOKE. Does this need to be documented?
256 .\" David Howells: No significance for user space.
265 This operation is exposed by
268 .BR keyctl_revoke (3).
270 .BR KEYCTL_CHOWN " (since Linux 2.6.10)"
271 Change the ownership (user and group ID) of a key.
282 contains the new user ID (or \-1 in case the user ID shouldn't be changed).
287 contains the new group ID (or \-1 in case the group ID shouldn't be changed).
289 The key must grant the caller
293 For the UID to be changed, or for the GID to be changed to a group
294 the caller is not a member of, the caller must have the
297 .BR capabilities (7)).
299 If the UID is to be changed, the new user must have sufficient
300 quota to accept the key.
301 The quota deduction will be removed from the old user
302 to the new user should the UID be changed.
308 This operation is exposed by
311 .BR keyctl_chown (3).
313 .BR KEYCTL_SETPERM " (since Linux 2.6.10)"
314 Change the permissions of the key with the ID provided in the
318 to the permissions provided in the
323 If the caller doesn't have the
325 capability, it can change permissions only for the keys it owns.
326 (More precisely: the caller's filesystem UID must match the UID of the key.)
330 permission to the caller
332 of the caller's capabilities.
333 .\" FIXME Above, is it really intended that a privileged process can't
334 .\" override the lack of the 'setattr' permission?
338 specify masks of available operations
339 for each of the following user categories:
342 .IR possessor " (since Linux 2.6.14)"
343 .\" commit 664cceb0093b755739e56572b836a99104ee8a75
344 This is the permission granted to a process that possesses the key
345 (has it attached searchably to one of the process's keyrings);
350 This is the permission granted to a process
351 whose filesystem UID matches the UID of the key.
354 This is the permission granted to a process
355 whose filesystem GID or any of its supplementary GIDs
356 matches the GID of the key.
359 This is the permission granted to other processes
360 that do not match the
372 categories are exclusive: if a process matches the
374 category, it will not receive permissions granted in the
376 category; if a process matches the
380 category, then it will not receive permissions granted in the
386 category grants permissions that are cumulative with the grants from the
393 Each permission mask is eight bits in size,
394 with only six bits currently used.
395 The available permissions are:
399 This permission allows reading attributes of a key.
401 This permission is required for the
405 The permission bits for each category are
413 This permission allows reading a key's payload.
415 This permission is required for the
419 The permission bits for each category are
427 This permission allows update or instantiation of a key's payload.
428 For a keyring, it allows keys to be linked and unlinked from the keyring,
430 This permission is required for the
439 The permission bits for each category are
447 This permission allows keyrings to be searched and keys to be found.
448 Searches can recurse only into nested keyrings that have
452 This permission is required for the
453 .BR KEYCTL_GET_KEYRING_ID ,
454 .BR KEYCTL_JOIN_SESSION_KEYRING ,
460 The permission bits for each category are
468 This permission allows a key or keyring to be linked to.
470 This permission is required for the
473 .B KEYCTL_SESSION_TO_PARENT
476 The permission bits for each category are
483 .IR setattr " (since Linux 2.6.15)."
484 This permission allows a key's UID, GID, and permissions mask to be changed.
486 This permission is required for the
493 The permission bits for each category are
494 .BR KEY_POS_SETATTR ,
495 .BR KEY_USR_SETATTR ,
496 .BR KEY_GRP_SETATTR ,
498 .BR KEY_OTH_SETATTR .
501 As a convenience, the following macros are defined as masks for
502 all of the permission bits in each of the user categories:
513 arguments are ignored.
515 This operation is exposed by
518 .BR keyctl_setperm (3).
520 .BR KEYCTL_DESCRIBE " (since Linux 2.6.10)"
521 Obtain a string describing the attributes of a specified key.
523 The ID of the key to be described is specified in
527 The descriptive string is returned in the buffer pointed to by
534 specifies the size of that buffer in bytes.
536 The key must grant the caller
540 The returned string is null-terminated and
541 contains the following information about the key:
544 .IR type ; uid ; gid ; perm ; description
555 are decimal strings, and
557 is a hexadecimal permissions mask.
558 The descriptive string is written with the following format:
566 .B Note: the intention is that the descriptive string should
567 .B be extensible in future kernel versions.
570 field will not contain semicolons;
571 .\" FIXME But, the kernel does not enforce the requirement
572 .\" that the key description contains no semicolons!
573 .\" So, user space has no guarantee here??
574 .\" Either something more needs to be said here,
575 .\" or a kernel fix is required.
576 it should be parsed by working backwards from the end of the string
577 to find the last semicolon.
578 This allows future semicolon-delimited fields to be inserted
579 in the descriptive string in the future.
581 Writing to the buffer is attempted only when
583 is non-NULL and the specified buffer size
584 is large enough to accept the descriptive string
585 (including the terminating null byte).
586 .\" Function commentary says it copies up to buflen bytes, but see the
587 .\" (buffer && buflen >= ret) condition in keyctl_describe_key() in
588 .\" security/keyctl.c
589 In order to determine whether the buffer size was too small,
590 check to see if the return value of the operation is greater than
597 This operation is exposed by
600 .BR keyctl_describe (3).
603 Clear the contents of (i.e., unlink all keys from) a keyring.
606 (which must be of keyring type)
607 .\" or the error ENOTDIR results
612 .\" According to Documentation/security/keys.txt:
613 .\" This function can also be used to clear special kernel keyrings if they
614 .\" are appropriately marked if the user has CAP_SYS_ADMIN capability. The
615 .\" DNS resolver cache keyring is an example of this.
619 permission on the keyring.
628 This operation is exposed by
631 .BR keyctl_clear (3).
633 .BR KEYCTL_LINK " (since Linux 2.6.10)"
634 Create a link from a keyring to a key.
636 The key to be linked is specified in
640 the keyring is specified in
645 If a key with the same type and description is already linked in the keyring,
646 then that key is displaced from the keyring.
648 Before creating the link,
649 the kernel checks the nesting of the keyrings and returns appropriate errors
650 if the link would produce a cycle
651 or if the nesting of keyrings would be too deep
652 (The limit on the nesting of keyrings is determined by the kernel constant
653 .BR KEYRING_SEARCH_MAX_DEPTH ,
654 defined with the value 6, and is necessary to prevent overflows
655 on the kernel stack when recursively searching keyrings).
659 permission on the key being added and
661 permission on the keyring.
669 This operation is exposed by
674 .BR KEYCTL_UNLINK " (since Linux 2.6.10)"
675 Unlink a key from a keyring.
677 The ID of the key to be unlinked is specified in
681 the ID of the keyring from which it is to be unlinked is specified in
686 If the key is not currently linked into the keyring, an error results.
690 permission on the keyring from which the key is being removed.
692 If the last link to a key is removed,
693 then that key will be scheduled for destruction.
701 This operation is exposed by
704 .BR keyctl_unlink (3).
706 .BR KEYCTL_SEARCH " (since Linux 2.6.10)"
707 Search for a key in a keyring tree,
708 returning its ID and optionally linking it to a specified keyring.
710 The tree to be searched is specified by passing
711 the ID of the head keyring in
715 The search is performed breadth-first and recursively.
721 arguments specify the key to be searched for:
725 contains the key type
726 (a null-terminated character string up to 32 bytes in size,
727 including the terminating null byte), and
731 contains the description of the key
732 (a null-terminated character string up to 4096 bytes in size,
733 including the terminating null byte).
735 The source keyring must grant
737 permission to the caller.
738 When performing the recursive search, only keyrings that grant the caller
740 permission will be searched.
741 Only keys with for which the caller has
743 permission can be found.
745 If the key is found, its ID is returned as the function result.
747 If the key is found and
751 is nonzero, then, subject to the same constraints and rules as
753 the key is linked into the keyring whose ID is specified in
755 If the destination keyring specified in
757 already contains a link to a key that has the same type and description,
758 then that link will be displaced by a link to
759 the key found by this operation.
761 Instead of valid existing keyring IDs, the source
765 keyrings can be one of the special keyring IDs listed under
766 .BR KEYCTL_GET_KEYRING_ID .
768 This operation is exposed by
771 .BR keyctl_search (3).
773 .BR KEYCTL_READ " (since Linux 2.6.10)"
774 Read the payload data of a key.
776 The ID of the key whose payload is to be read is specified in
780 This can be the ID of an existing key,
781 or any of the special key IDs listed for
782 .BR KEYCTL_GET_KEYRING_ID .
783 .\" including KEY_SPEC_REQKEY_AUTH_KEY
785 The payload is placed in the buffer pointed by
789 the size of that buffer must be specified in
794 The returned data will be processed for presentation
795 according to the key type.
796 For example, a keyring will return an array of
798 entries representing the IDs of all the keys that are linked to it.
801 key type will return its data as is.
802 If a key type does not implement this function,
803 the operation fails with the error
809 as much of the payload data as will fit is copied into the buffer.
810 On a successful return,
811 the return value is always the total size of the payload data.
812 To determine whether the buffer was of sufficient size,
813 check to see that the return value is less than or equal to
814 the value supplied in
817 The key must either grant the caller
819 permission, or grant the caller
821 permission when searched for from the process keyrings
822 (i.e., the key is possessed).
828 This operation is exposed by
833 .BR KEYCTL_INSTANTIATE " (since Linux 2.6.10)"
834 (Positively) instantiate an uninstantiated key with a specified payload.
836 The ID of the key to be instantiated is provided in
841 The key payload is specified in the buffer pointed to by
845 the size of that buffer is specified in
850 The payload may be a NULL pointer and the buffer size may be 0
851 if this is supported by the key type (e.g., it is a keyring).
853 The operation may be fail if the payload data is in the wrong format
854 or is otherwise invalid.
860 is nonzero, then, subject to the same constraints and rules as
862 the instantiated key is linked into the keyring whose ID specified in
865 The caller must have the appropriate authorization key,
866 and once the uninstantiated key has been instantiated,
867 the authorization key is revoked.
868 In other words, this operation is available only from a
869 .BR request\-key (8)-style
873 for an explanation of uninstantiated keys and key instantiation.
875 This operation is exposed by
878 .BR keyctl_instantiate (3).
880 .BR KEYCTL_NEGATE " (since Linux 2.6.10)"
881 Negatively instantiate an uninstantiated key.
883 This operation is equivalent to the call:
887 keyctl(KEYCTL_REJECT, arg2, arg3, ENOKEY, arg4);
895 This operation is exposed by
898 .BR keyctl_negate (3).
900 .BR KEYCTL_SET_REQKEY_KEYRING " (since Linux 2.6.13)"
901 Set the default keyring to which implicitly requested keys
902 will be linked for this thread, and return the previous setting.
903 Implicit key requests are those made by internal kernel components,
904 .\" I.e., calls to the kernel's internal request_key() interface,
905 .\" which is distinct from the request_key(2) system call (which
906 .\" ultimately employs the kernel-internal interface).
907 such as can occur when, for example, opening files
908 on an AFS or NFS filesystem.
909 Setting the default keyring also has an effect when requesting
910 a key from user space; see
918 should contain one of the following values,
919 to specify the new default keyring:
922 .B KEY_REQKEY_DEFL_NO_CHANGE
923 Don't change the default keyring.
924 This can be used to discover the current default keyring
925 (without changing it).
927 .B KEY_REQKEY_DEFL_DEFAULT
928 This selects the default behaviour,
929 which is to use the thread-specific keyring if there is one,
930 otherwise the process-specific keyring if there is one,
931 otherwise the session keyring if there is one,
932 otherwise the UID-specific session keyring,
933 otherwise the user-specific keyring.
935 .B KEY_REQKEY_DEFL_THREAD_KEYRING
936 Use the thread-specific keyring
937 .RB ( thread\-keyring (7))
938 as the new default keyring.
940 .B KEY_REQKEY_DEFL_PROCESS_KEYRING
941 Use the process-specific keyring
942 .RB ( process\-keyring (7))
943 as the new default keyring.
945 .B KEY_REQKEY_DEFL_SESSION_KEYRING
946 Use the session-specific keyring
947 .RB ( session\-keyring (7))
948 as the new default keyring.
950 .B KEY_REQKEY_DEFL_USER_KEYRING
951 Use the UID-specific keyring
952 .RB ( user\-keyring (7))
953 as the new default keyring.
955 .B KEY_REQKEY_DEFL_USER_SESSION_KEYRING
956 Use the UID-specific session keyring
957 .RB ( user\-session\-keyring (7))
958 as the new default keyring.
960 .BR KEY_REQKEY_DEFL_REQUESTOR_KEYRING " (since Linux 2.6.29)"
961 .\" 8bbf4976b59fc9fc2861e79cab7beb3f6d647640
962 Use the requestor keyring.
963 .\" FIXME The preceding explanation needs to be expanded.
964 .\" Is the following correct:
966 .\" The requestor keyring is the dest_keyring that
967 .\" was supplied to a call to request_key(2)?
969 .\" David Howells said: to be checked
972 All other values are invalid.
973 .\" (including the still-unsupported KEY_REQKEY_DEFL_GROUP_KEYRING)
982 The setting controlled by this operation is inherited by the child of
987 This operation is exposed by
990 .BR keyctl_set_reqkey_keyring (3).
992 .BR KEYCTL_SET_TIMEOUT " (since Linux 2.6.16)"
993 Set a timeout on a key.
995 The ID of the key is specified in
999 The timeout value, in seconds from the current time,
1003 .IR "unsigned int" ).
1004 The timeout is measured against the realtime clock.
1006 Specifying the timeout value as 0 clears any existing timeout on the key.
1010 file displays the remaining time until each key will expire.
1011 (This is the only method of discovering the timeout on a key.)
1013 The caller must either have the
1015 permission on the key
1016 or hold an instantiation authorization token for the key (see
1017 .BR request_key (2)).
1019 The key and any links to the key will be
1020 automatically garbage collected after the timeout expires.
1021 Subsequent attempts to access the key will then fail with the error
1024 This operation cannot be used to set timeouts on revoked, expired,
1025 or negatively instantiated keys.
1033 This operation is exposed by
1036 .BR keyctl_set_timeout (3).
1038 .BR KEYCTL_ASSUME_AUTHORITY " (since Linux 2.6.16)"
1039 Assume (or divest) the authority for the calling thread
1040 to instantiate a key.
1046 specifies either a nonzero key ID to assume authority,
1047 or the value 0 to divest authority.
1051 is nonzero, then it specifies the ID of an uninstantiated key for which
1052 authority is to be assumed.
1053 That key can then be instantiated using one of
1054 .BR KEYCTL_INSTANTIATE ,
1055 .BR KEYCTL_INSTANTIATE_IOV ,
1059 Once the key has been instantiated,
1060 the thread is automatically divested of authority to instantiate the key.
1062 Authority over a key can be assumed only if the calling thread has present
1063 in its keyrings the authorization key that is
1064 associated with the specified key.
1065 (In other words, the
1066 .B KEYCTL_ASSUME_AUTHORITY
1067 operation is available only from a
1068 .BR request\-key (8)-style
1071 for an explanation of how this operation is used.)
1072 The caller must have
1074 permission on the authorization key.
1076 If the specified key has a matching authorization key,
1077 then the ID of that key is returned.
1078 The authorization key can be read
1080 to obtain the callout information passed to
1081 .BR request_key (2).
1085 is 0, then the currently assumed authority is cleared (divested),
1086 and the value 0 is returned.
1089 .B KEYCTL_ASSUME_AUTHORITY
1090 mechanism allows a program such as
1091 .BR request\-key (8)
1092 to assume the necessary authority to instantiate a new uninstantiated key
1093 that was created as a consequence of a call to
1094 .BR request_key (2).
1095 For further information, see
1097 and the kernel source file
1098 .IR Documentation/security/keys\-request\-key.txt .
1107 This operation is exposed by
1110 .BR keyctl_assume_authority (3).
1112 .BR KEYCTL_GET_SECURITY " (since Linux 2.6.26)"
1113 .\" commit 70a5bb72b55e82fbfbf1e22cae6975fac58a1e2d
1114 Get the LSM (Linux Security Module) security label of the specified key.
1116 The ID of the key whose security label is to be fetched is specified in
1120 The security label (terminated by a null byte)
1121 will be placed in the buffer pointed to by
1125 the size of the buffer must be provided in
1132 is specified as NULL or the buffer size specified in
1134 is too small, the full size of the security label string
1135 (including the terminating null byte)
1136 is returned as the function result,
1137 and nothing is copied to the buffer.
1139 The caller must have
1141 permission on the specified key.
1143 The returned security label string will be rendered in a form appropriate
1144 to the LSM in force.
1145 For example, with SELinux, it may look like:
1149 unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
1153 If no LSM is currently in force,
1154 then an empty string is placed in the buffer.
1158 argument is ignored.
1160 This operation is exposed by
1163 .BR keyctl_get_security (3)
1165 .BR keyctl_get_security_alloc (3).
1167 .BR KEYCTL_SESSION_TO_PARENT " (since Linux 2.6.32)"
1168 .\" commit ee18d64c1f632043a02e6f5ba5e045bb26a5465f
1169 Replace the session keyring to which the
1171 of the calling process
1172 subscribes with the session keyring of the calling process.
1173 .\" What is the use case for KEYCTL_SESSION_TO_PARENT?
1174 .\" David Howells: the Process Authentication Groups people requested this,
1175 .\" but then didn't use it; maybe there are no users.
1177 The keyring will be replaced in the parent process at the point
1178 where the parent next transitions from kernel space to user space.
1180 The keyring must exist and must grant the caller
1183 The parent process must be single-threaded and have
1184 the same effective ownership as this process
1185 and must not be set-user-ID or set-group-ID.
1186 The UID of the parent process's existing session keyring (f it has one),
1187 as well as the UID of the caller's session keyring
1188 much match the caller's effective UID.
1190 The fact that it is the parent process that is affected by this operation
1191 allows a program such as the shell to start a child process that
1192 uses this operation to change the shell's session keyring.
1206 This operation is exposed by
1209 .BR keyctl_session_to_parent (3).
1211 .BR KEYCTL_REJECT " (since Linux 2.6.39)"
1212 .\" commit fdd1b94581782a2ddf9124414e5b7a5f48ce2f9c
1213 Mark a key as negatively instantiated and set an expiration timer
1215 This operation provides a superset of the functionality of the earlier
1219 The ID of the key that is to be negatively instantiated is specified in
1226 .IR "unsigned int" )
1227 argument specifies the lifetime of the key, in seconds.
1231 .IR "unsigned int" )
1232 specifies the error to be returned when a search hits this key;
1233 typically, this is one of
1243 is nonzero, then, subject to the same constraints and rules as
1245 the negatively instantiated key is linked into the keyring
1246 whose ID is specified in
1249 The caller must have the appropriate authorization key.
1250 In other words, this operation is available only from a
1251 .BR request\-key (8)-style
1254 .BR request_key (2).
1256 The caller must have the appropriate authorization key,
1257 and once the uninstantiated key has been instantiated,
1258 the authorization key is revoked.
1259 In other words, this operation is available only from a
1260 .BR request\-key (8)-style
1264 for an explanation of uninstantiated keys and key instantiation.
1266 This operation is exposed by
1269 .BR keyctl_reject (3).
1271 .BR KEYCTL_INSTANTIATE_IOV " (since Linux 2.6.39)"
1272 .\" commit ee009e4a0d4555ed522a631bae9896399674f063
1273 Instantiate an uninstantiated key with a payload specified
1274 via a vector of buffers.
1276 This operation is the same as
1277 .BR KEYCTL_INSTANTIATE ,
1278 but the payload data is specified as an array of
1285 void *iov_base; /* Starting address of buffer */
1286 size_t iov_len; /* Size of buffer (in bytes) */
1291 The pointer to the payload vector is specified in
1294 .IR "const struct iovec\~*" ).
1295 The number of items in the vector is specified in
1298 .IR "unsigned int" ).
1306 are interpreted as for
1307 .BR KEYCTL_INSTANTIATE .
1309 This operation is exposed by
1312 .BR keyctl_instantiate_iov (3).
1314 .BR KEYCTL_INVALIDATE " (since Linux 3.5)"
1315 .\" commit fd75815f727f157a05f4c96b5294a4617c0557da
1316 Mark a key as invalid.
1318 The ID of the key to be invalidated is specified in
1323 To invalidate a key,
1324 the caller must have
1326 permission on the key.
1327 .\" CAP_SYS_ADMIN is permitted to invalidate certain special keys
1329 This operation marks the key as invalid
1330 and schedules immediate garbage collection.
1331 The garbage collector removes the invalidated key from all keyrings and
1332 deletes the key when its reference count reaches zero.
1333 After this operation,
1334 the key will be ignored by all searches,
1335 even if it is not yet deleted.
1337 Keys that are marked invalid become invisible to normal key operations
1338 immediately, though they are still visible in
1340 (marked with an 'i' flag)
1341 until they are actually removed.
1350 This operation is exposed by
1353 .BR keyctl_invalidate (3).
1355 .BR KEYCTL_GET_PERSISTENT " (since Linux 3.13)"
1356 .\" commit f36f8c75ae2e7d4da34f4c908cebdb4aa42c977e
1357 Get the persistent keyring
1358 .RB ( persistent\-keyring (7))
1359 for a specified user and link it to a specified keyring.
1361 The user ID is specified in
1365 If the value \-1 is specified, the caller's real user ID is used.
1366 The ID of the destination keyring is specified in
1371 The caller must have the
1373 capability in its user namespace in order to fetch the persistent keyring
1374 for a user ID that does not match either the real or effective user ID
1377 If the call is successful,
1378 a link to the persistent keyring is added to the keyring
1379 whose ID was specified in
1382 The caller must have
1384 permission on the keyring.
1386 The persistent keyring will be created by the kernel
1387 if it does not yet exist.
1390 .B KEYCTL_GET_PERSISTENT
1391 operation is performed, the persistent keyring will
1392 have its expiration timeout reset to the value in:
1396 /proc/sys/kernel/keys/persistent_keyring_expiry
1400 Should the timeout be reached,
1401 the persistent keyring will be removed and
1402 everything it pins can then be garbage collected.
1404 Persistent keyrings were added to Linux in kernel version 3.13.
1412 This operation is exposed by
1415 .BR keyctl_get_persistent (3).
1417 .BR KEYCTL_DH_COMPUTE " (since Linux 4.7)"
1418 .\" commit ddbb41148724367394d0880c516bfaeed127b52e
1419 Compute a Diffie-Hellman shared secret or public key,
1420 optionally applying key derivation function (KDF) to the result.
1424 argument is a pointer to a set of parameters containing
1425 serial numbers for three
1427 keys used in the Diffie-Hellman calculation,
1428 packaged in a structure of the following form:
1432 struct keyctl_dh_params {
1433 int32_t private; /* The local private key */
1434 int32_t prime; /* The prime, known to both parties */
1435 int32_t base; /* The base integer: either a shared
1436 generator or the remote public key */
1441 Each of the three keys specified in this structure must grant the caller
1444 The payloads of these keys are used to calculate the Diffie-Hellman
1449 base \(ha private mod prime
1453 If the base is the shared generator, the result is the local public key.
1454 If the base is the remote public key, the result is the shared secret.
1460 points to a buffer where the result of the calculation is placed.
1461 The size of that buffer is specified in
1466 The buffer must be large enough to accommodate the output data,
1467 otherwise an error is returned.
1471 in which case the buffer is not used and
1472 the operation returns the minimum required buffer size
1473 (i.e., the length of the prime).
1475 Diffie-Hellman computations can be performed in user space,
1476 but require a multiple-precision integer (MPI) library.
1477 Moving the implementation into the kernel gives access to
1478 the kernel MPI implementation,
1479 and allows access to secure or acceleration hardware.
1481 Adding support for DH computation to the
1483 system call was considered a good fit due to the DH algorithm's use
1484 for deriving shared keys;
1485 it also allows the type of the key to determine
1486 which DH implementation (software or hardware) is appropriate.
1487 .\" commit f1c316a3ab9d24df6022682422fe897492f2c0c8
1493 then the DH result itself is returned.
1494 Otherwise (since Linux 4.12), it is a pointer to a structure which specifies
1495 parameters of the KDF operation to be applied:
1499 struct keyctl_kdf_params {
1500 char *hashname; /* Hash algorithm name */
1501 char *otherinfo; /* SP800\-56A OtherInfo */
1502 __u32 otherinfolen; /* Length of otherinfo data */
1503 __u32 __spare[8]; /* Reserved */
1510 field is a null-terminated string which specifies a hash name
1511 (available in the kernel's crypto API; the list of the hashes available
1512 is rather tricky to observe; please refer to the
1513 .UR https://www.kernel.org\:/doc\:/html\:/latest\:/crypto\:/architecture.html
1514 "Kernel Crypto API Architecture"
1516 documentation for the information regarding how hash names are constructed and
1517 your kernel's source and configuration regarding what ciphers
1518 and templates with type
1519 .B CRYPTO_ALG_TYPE_SHASH
1521 to be applied to DH result in KDF operation.
1527 data as described in SP800-56A section 5.8.1.2 and is algorithm-specific.
1528 This data is concatenated with the result of DH operation and is provided as
1529 an input to the KDF operation.
1530 Its size is provided in the
1532 field and is limited by
1533 .B KEYCTL_KDF_MAX_OI_LEN
1534 constant that defined in
1535 .I security/keys/internal.h
1540 field is currently unused.
1541 .\" commit 4f9dabfaf8df971f8a3b6aa324f8f817be38d538
1542 It was ignored until Linux 4.13 (but still should be
1543 user-addressable since it is copied to the kernel),
1544 and should contain zeros since Linux 4.13.
1546 The KDF implementation complies with SP800-56A as well
1547 as with SP800-108 (the counter KDF).
1549 .\" keyutils commit 742c9d7b94051d3b21f9f61a73ed6b5f3544cb82
1550 .\" keyutils commit d68a981e5db41d059ac782071c35d1e8f3aaf61c
1551 This operation is exposed by
1553 (from version 1.5.10 onwards) via the functions
1554 .BR keyctl_dh_compute (3)
1556 .BR keyctl_dh_compute_alloc (3).
1558 .BR KEYCTL_RESTRICT_KEYRING " (since Linux 4.12)"
1559 .\" commit 6563c91fd645556c7801748f15bc727c77fcd311
1560 .\" commit 7228b66aaf723a623e578aa4db7d083bb39546c9
1561 Apply a key-linking restriction to the keyring with the ID provided in
1565 The caller must have
1567 permission on the key.
1570 is NULL, any attempt to add a key to the keyring is blocked;
1571 otherwise it contains a pointer to a string with a key type name and
1573 contains a pointer to string that describes the type-specific restriction.
1574 As of Linux 4.12, only the type "asymmetric" has restrictions defined:
1578 Allows only keys that are signed by a key linked to the built-in keyring
1579 (".builtin_trusted_keys").
1581 .B builtin_and_secondary_trusted
1582 Allows only keys that are signed by a key linked to the secondary keyring
1583 (".secondary_trusted_keys") or, by extension, a key in a built-in keyring,
1584 as the latter is linked to the former.
1586 .BI key_or_keyring: key
1588 .BI key_or_keyring: key :chain
1591 specifies the ID of a key of type "asymmetric",
1592 then only keys that are signed by this key are allowed.
1596 specifies the ID of a keyring,
1597 then only keys that are signed by a key linked
1598 to this keyring are allowed.
1600 If ":chain" is specified, keys that are signed by a keys linked to the
1601 destination keyring (that is, the keyring with the ID specified in the
1603 argument) are also allowed.
1606 Note that a restriction can be configured only once for the specified keyring;
1607 once a restriction is set, it can't be overridden.
1612 .\" FIXME Document KEYCTL_RESTRICT_KEYRING, added in Linux 4.12
1613 .\" commit 6563c91fd645556c7801748f15bc727c77fcd311
1614 .\" Author: Mat Martineau <mathew.j.martineau@linux.intel.com>
1615 .\" See Documentation/security/keys.txt
1617 For a successful call, the return value depends on the operation:
1619 .B KEYCTL_GET_KEYRING_ID
1620 The ID of the requested keyring.
1622 .B KEYCTL_JOIN_SESSION_KEYRING
1623 The ID of the joined session keyring.
1626 The size of the description (including the terminating null byte),
1627 irrespective of the provided buffer size.
1630 The ID of the key that was found.
1633 The amount of data that is available in the key,
1634 irrespective of the provided buffer size.
1636 .B KEYCTL_SET_REQKEY_KEYRING
1637 The ID of the previous default keyring
1638 to which implicitly requested keys were linked
1640 .BR KEY_REQKEY_DEFL_USER_* ).
1642 .B KEYCTL_ASSUME_AUTHORITY
1643 Either 0, if the ID given was 0,
1644 or the ID of the authorization key matching the specified key,
1645 if a nonzero key ID was provided.
1647 .B KEYCTL_GET_SECURITY
1648 The size of the LSM security label string
1649 (including the terminating null byte),
1650 irrespective of the provided buffer size.
1652 .B KEYCTL_GET_PERSISTENT
1653 The ID of the persistent keyring.
1655 .B KEYCTL_DH_COMPUTE
1656 The number of bytes copied to the buffer, or, if
1658 is 0, the required buffer size.
1660 All other operations
1663 On error, \-1 is returned, and
1665 is set to indicate the error.
1669 The requested operation wasn't permitted.
1674 .B KEYCTL_DH_COMPUTE
1675 and there was an error during crypto module initialization.
1681 and the requested link would result in a cycle.
1686 .B KEYCTL_RESTRICT_KEYRING
1687 and the requested keyring restriction would result in a cycle.
1690 The key quota for the caller's user would be exceeded by creating a key or
1691 linking it to the keyring.
1696 .B KEYCTL_RESTRICT_KEYRING
1697 and keyring provided in
1699 argument already has a restriction set.
1704 .B KEYCTL_DH_COMPUTE
1705 and one of the following has failed:
1709 .IR "struct keyctl_dh_params" ,
1712 argument, from user space;
1715 .IR "struct keyctl_kdf_params" ,
1716 provided in the non-NULL
1718 argument, from user space
1719 (in case kernel supports performing KDF operation on DH operation result);
1721 copying of data pointed by the
1724 .I "struct keyctl_kdf_params"
1727 copying of data pointed by the
1730 .I struct keyctl_kdf_params
1731 from user space if the
1735 copying of the result to user space.
1742 and an invalid permission bit was specified in
1749 and the size of the description in
1751 (including the terminating null byte) exceeded 4096 bytes.
1754 size of the string (including the terminating null byte) specified in
1759 (the key description)
1760 exceeded the limit (32 bytes and 4096 bytes respectively).
1762 .BR EINVAL " (Linux kernels before 4.12)"
1765 .BR KEYCTL_DH_COMPUTE ,
1773 .B KEYCTL_DH_COMPUTE
1774 And the digest size of the hashing algorithm supplied is zero.
1779 .B KEYCTL_DH_COMPUTE
1780 and the buffer size provided is not enough to hold the result.
1781 Provide 0 as a buffer size in order to obtain the minimum buffer size.
1786 .B KEYCTL_DH_COMPUTE
1787 and the hash name provided in the
1790 .I struct keyctl_kdf_params
1793 argument is too big (the limit is implementation-specific and varies between
1794 kernel versions, but it is deemed big enough for all valid algorithm names).
1797 .\" commit 4f9dabfaf8df971f8a3b6aa324f8f817be38d538
1800 .B KEYCTL_DH_COMPUTE
1804 .I struct keyctl_kdf_params
1807 argument contains nonzero values.
1810 An expired key was found or specified.
1813 A rejected key was found or specified.
1816 A revoked key was found or specified.
1822 and the requested link would cause the maximum nesting depth
1823 for keyrings to be exceeded.
1828 .B KEYCTL_DH_COMPUTE
1829 and the buffer length exceeds
1830 .B KEYCTL_KDF_MAX_OUTPUT_LEN
1831 (which is 1024 currently)
1835 .I struct keyctl_kdf_parms
1839 .B KEYCTL_KDF_MAX_OI_LEN
1840 (which is 64 currently).
1842 .BR ENFILE " (Linux kernels before 3.13)"
1846 and the keyring is full.
1848 .\" commit b2a4df200d570b2c33a57e1ebfa5896e4bc81b69
1849 the available space for storing keyring links was limited to
1850 a single page of memory; since Linux 3.13, there is no fixed limit.)
1856 and the key to be unlinked isn't linked to the keyring.
1861 .B KEYCTL_DH_COMPUTE
1862 and the hashing algorithm specified in the
1865 .I struct keyctl_kdf_params
1868 argument hasn't been found.
1873 .B KEYCTL_RESTRICT_KEYRING
1874 and the type provided in
1876 argument doesn't support setting key linking restrictions.
1879 No matching key was found or an invalid key was specified.
1883 .B KEYCTL_GET_KEYRING_ID
1886 the key specified in
1890 was zero (meaning don't create the key if it didn't exist).
1893 One of kernel memory allocation routines failed during the execution of the
1897 A key of keyring type was expected but the ID of a key with
1898 a different type was provided.
1904 and the key type does not support reading
1912 and the key type does not support updating.
1917 .BR KEYCTL_RESTRICT_KEYRING ,
1918 the type provided in
1920 argument was "asymmetric", and the key specified in the restriction specification
1923 has type other than "asymmetric" or "keyring".
1928 .BR KEYCTL_GET_PERSISTENT ,
1930 specified a UID other than the calling thread's real or effective UID,
1931 and the caller did not have the
1938 .B KEYCTL_SESSION_TO_PARENT
1940 all of the UIDs (GIDs) of the parent process do not match
1941 the effective UID (GID) of the calling process;
1942 the UID of the parent's existing session keyring or
1943 the UID of the caller's session keyring did not match
1944 the effective UID of the caller;
1945 the parent process is not single-thread;
1946 or the parent process is
1953 .B KEYCTL_DH_COMPUTE
1954 and the initialization of crypto modules has timed out.
1956 This system call first appeared in Linux 2.6.10.
1958 This system call is a nonstandard Linux extension.
1960 A wrapper is provided in the
1963 (The accompanying package provides the
1966 However, rather than using this system call directly,
1967 you probably want to use the various library functions
1968 mentioned in the descriptions of individual operations above.
1970 The program below provide subset of the functionality of the
1971 .BR request\-key (8)
1972 program provided by the
1975 For informational purposes,
1976 the program records various information in a log file.
1979 .BR request_key (2),
1981 .BR request\-key (8)
1982 program is invoked with command-line arguments that
1983 describe a key that is to be instantiated.
1984 The example program fetches and logs these arguments.
1985 The program assumes authority to instantiate the requested key,
1986 and then instantiates that key.
1988 The following shell session demonstrates the use of this program.
1990 we compile the program and then use it to temporarily replace the standard
1991 .BR request\-key (8)
1993 (Note that temporarily disabling the standard
1994 .BR request\-key (8)
1995 program may not be safe on some systems.)
1996 While our example program is installed,
1997 we use the example program shown in
2003 $ \fBcc \-o key_instantiate key_instantiate.c \-lkeyutils\fP
2004 $ \fBsudo mv /sbin/request\-key /sbin/request\-key.backup\fP
2005 $ \fBsudo cp key_instantiate /sbin/request\-key\fP
2006 $ \fB./t_request_key user mykey somepayloaddata\fP
2008 $ \fBsudo mv /sbin/request\-key.backup /sbin/request\-key\fP
2012 Looking at the log file created by this program,
2013 we can see the command-line arguments supplied to our example program:
2017 $ \fBcat /tmp/key_instantiate.log\fP
2018 Time: Mon Nov 7 13:06:47 2016
2020 Command line arguments:
2021 argv[0]: /sbin/request\-key
2023 key_to_instantiate: 20d035bf
2028 session_keyring: 256e6a6
2030 Key description: user;1000;1000;3f010000;mykey
2031 Auth key payload: somepayloaddata
2032 Destination keyring: 256e6a6
2033 Auth key description: .request_key_auth;1000;1000;0b010000;20d035bf
2037 The last few lines of the above output show that the example program
2040 the description of the key to be instantiated,
2041 which included the name of the key
2044 the payload of the authorization key, which consisted of the data
2045 .RI ( somepayloaddata )
2047 .BR request_key (2);
2049 the destination keyring that was specified in the call to
2050 .BR request_key (2);
2053 the description of the authorization key,
2054 where we can see that the name of the authorization key matches
2055 the ID of the key that is to be instantiated
2058 The example program in
2060 specified the destination keyring as
2061 .BR KEY_SPEC_SESSION_KEYRING .
2062 By examining the contents of
2064 we can see that this was translated to the ID of the destination keyring
2066 shown in the log output above;
2067 we can also see the newly created key with the name
2074 $ \fBcat /proc/keys | egrep \(aqmykey|256e6a6\(aq\fP
2075 0256e6a6 I\-\-Q\-\-\- 194 perm 3f030000 1000 1000 keyring _ses: 3
2076 20d035bf I\-\-Q\-\-\- 1 perm 3f010000 1000 1000 user mykey: 16
2082 /* key_instantiate.c */
2084 #include <sys/types.h>
2085 #include <keyutils.h>
2095 #ifndef KEY_SPEC_REQUESTOR_KEYRING
2096 #define KEY_SPEC_REQUESTOR_KEYRING \-8
2100 main(int argc, char *argv[])
2105 key_serial_t key_to_instantiate, dest_keyring;
2106 key_serial_t thread_keyring, process_keyring, session_keyring;
2110 char auth_key_payload[256];
2111 int akp_size; /* Size of auth_key_payload */
2114 fp = fopen("/tmp/key_instantiate.log", "w");
2121 fprintf(fp, "Time: %s\en", ctime(&t));
2124 * The kernel passes a fixed set of arguments to the program
2125 * that it execs; fetch them.
2127 operation = argv[1];
2128 key_to_instantiate = atoi(argv[2]);
2129 uid = atoi(argv[3]);
2130 gid = atoi(argv[4]);
2131 thread_keyring = atoi(argv[5]);
2132 process_keyring = atoi(argv[6]);
2133 session_keyring = atoi(argv[7]);
2135 fprintf(fp, "Command line arguments:\en");
2136 fprintf(fp, " argv[0]: %s\en", argv[0]);
2137 fprintf(fp, " operation: %s\en", operation);
2138 fprintf(fp, " key_to_instantiate: %jx\en",
2139 (uintmax_t) key_to_instantiate);
2140 fprintf(fp, " UID: %jd\en", (intmax_t) uid);
2141 fprintf(fp, " GID: %jd\en", (intmax_t) gid);
2142 fprintf(fp, " thread_keyring: %jx\en",
2143 (uintmax_t) thread_keyring);
2144 fprintf(fp, " process_keyring: %jx\en",
2145 (uintmax_t) process_keyring);
2146 fprintf(fp, " session_keyring: %jx\en",
2147 (uintmax_t) session_keyring);
2151 * Assume the authority to instantiate the key named in argv[2].
2153 if (keyctl(KEYCTL_ASSUME_AUTHORITY, key_to_instantiate) == \-1) {
2154 fprintf(fp, "KEYCTL_ASSUME_AUTHORITY failed: %s\en",
2160 * Fetch the description of the key that is to be instantiated.
2162 if (keyctl(KEYCTL_DESCRIBE, key_to_instantiate,
2163 dbuf, sizeof(dbuf)) == \-1) {
2164 fprintf(fp, "KEYCTL_DESCRIBE failed: %s\en", strerror(errno));
2168 fprintf(fp, "Key description: %s\en", dbuf);
2171 * Fetch the payload of the authorization key, which is
2172 * actually the callout data given to request_key().
2174 akp_size = keyctl(KEYCTL_READ, KEY_SPEC_REQKEY_AUTH_KEY,
2175 auth_key_payload, sizeof(auth_key_payload));
2176 if (akp_size == \-1) {
2177 fprintf(fp, "KEYCTL_READ failed: %s\en", strerror(errno));
2181 auth_key_payload[akp_size] = \(aq\e0\(aq;
2182 fprintf(fp, "Auth key payload: %s\en", auth_key_payload);
2185 * For interest, get the ID of the authorization key and
2188 auth_key = keyctl(KEYCTL_GET_KEYRING_ID,
2189 KEY_SPEC_REQKEY_AUTH_KEY);
2190 if (auth_key == \-1) {
2191 fprintf(fp, "KEYCTL_GET_KEYRING_ID failed: %s\en",
2196 fprintf(fp, "Auth key ID: %jx\en", (uintmax_t) auth_key);
2199 * Fetch key ID for the request_key(2) destination keyring.
2201 dest_keyring = keyctl(KEYCTL_GET_KEYRING_ID,
2202 KEY_SPEC_REQUESTOR_KEYRING);
2203 if (dest_keyring == \-1) {
2204 fprintf(fp, "KEYCTL_GET_KEYRING_ID failed: %s\en",
2209 fprintf(fp, "Destination keyring: %jx\en", (uintmax_t) dest_keyring);
2212 * Fetch the description of the authorization key. This
2213 * allows us to see the key type, UID, GID, permissions,
2214 * and description (name) of the key. Among other things,
2215 * we will see that the name of the key is a hexadecimal
2216 * string representing the ID of the key to be instantiated.
2218 if (keyctl(KEYCTL_DESCRIBE, KEY_SPEC_REQKEY_AUTH_KEY,
2219 dbuf, sizeof(dbuf)) == \-1) {
2220 fprintf(fp, "KEYCTL_DESCRIBE failed: %s\en", strerror(errno));
2224 fprintf(fp, "Auth key description: %s\en", dbuf);
2227 * Instantiate the key using the callout data that was supplied
2228 * in the payload of the authorization key.
2230 if (keyctl(KEYCTL_INSTANTIATE, key_to_instantiate,
2231 auth_key_payload, akp_size + 1, dest_keyring) == \-1) {
2232 fprintf(fp, "KEYCTL_INSTANTIATE failed: %s\en",
2245 .BR request_key (2),
2246 .\" .BR find_key_by_type_and_name (3)
2247 .\" There is a man page, but this function seems not to exist
2249 .BR keyctl_assume_authority (3),
2250 .BR keyctl_chown (3),
2251 .BR keyctl_clear (3),
2252 .BR keyctl_describe (3),
2253 .BR keyctl_describe_alloc (3),
2254 .BR keyctl_dh_compute (3),
2255 .BR keyctl_dh_compute_alloc (3),
2256 .BR keyctl_get_keyring_ID (3),
2257 .BR keyctl_get_persistent (3),
2258 .BR keyctl_get_security (3),
2259 .BR keyctl_get_security_alloc (3),
2260 .BR keyctl_instantiate (3),
2261 .BR keyctl_instantiate_iov (3),
2262 .BR keyctl_invalidate (3),
2263 .BR keyctl_join_session_keyring (3),
2264 .BR keyctl_link (3),
2265 .BR keyctl_negate (3),
2266 .BR keyctl_read (3),
2267 .BR keyctl_read_alloc (3),
2268 .BR keyctl_reject (3),
2269 .BR keyctl_revoke (3),
2270 .BR keyctl_search (3),
2271 .BR keyctl_session_to_parent (3),
2272 .BR keyctl_set_reqkey_keyring (3),
2273 .BR keyctl_set_timeout (3),
2274 .BR keyctl_setperm (3),
2275 .BR keyctl_unlink (3),
2276 .BR keyctl_update (3),
2277 .BR recursive_key_scan (3),
2278 .BR recursive_session_key_scan (3),
2279 .BR capabilities (7),
2280 .BR credentials (7),
2283 .BR persistent\-keyring (7),
2284 .BR process\-keyring (7),
2285 .BR session\-keyring (7),
2286 .BR thread\-keyring (7),
2287 .BR user\-keyring (7),
2288 .BR user_namespaces (7),
2289 .BR user\-session\-keyring (7),
2290 .BR request\-key (8)
2292 The kernel source files under
2293 .I Documentation/security/keys/
2294 (or, before Linux 4.13, in the file
2295 .IR Documentation/security/keys.txt ).
projects / thirdparty / man-pages.git / blob