Merge branch 'sa1100' into devel

[safe/jmp/linux-2.6] / Documentation / keys.txt

diff --git a/Documentation/keys.txt b/Documentation/keys.txt
index 947d57d..e4dbbdb 100644 (file)
--- a/Documentation/keys.txt
+++ b/Documentation/keys.txt
@@ -4,7 +4,7 @@
 
 This service allows cryptographic keys, authentication tokens, cross-domain
 user mappings, and similar to be cached in the kernel for the use of
 
 This service allows cryptographic keys, authentication tokens, cross-domain
 user mappings, and similar to be cached in the kernel for the use of

-filesystems other kernel services.
+filesystems and other kernel services.

 
 Keyrings are permitted; these are a special type of key that can hold links to
 other keys. Processes each have three standard keyring subscriptions that a
 
 Keyrings are permitted; these are a special type of key that can hold links to
 other keys. Processes each have three standard keyring subscriptions that a


@@ -26,7 +26,7 @@ This document has the following sections:
        - Notes on accessing payload contents
        - Defining a key type
        - Request-key callback service
        - Notes on accessing payload contents
        - Defining a key type
        - Request-key callback service

-       - Key access filesystem
+       - Garbage collection

 
 
 ============
 
 
 ============


@@ -113,6 +113,9 @@ Each key has a number of attributes:
 
      (*) Dead. The key's type was unregistered, and so the key is now useless.
 
 
      (*) Dead. The key's type was unregistered, and so the key is now useless.
 

+Keys in the last three states are subject to garbage collection.  See the
+section on "Garbage collection".
+

 
 ====================
 KEY SERVICE OVERVIEW
 
 ====================
 KEY SERVICE OVERVIEW


@@ -170,7 +173,8 @@ The key service provides a number of features besides keys:
      amount of description and payload space that can be consumed.
 
      The user can view information on this and other statistics through procfs
      amount of description and payload space that can be consumed.
 
      The user can view information on this and other statistics through procfs

-     files.
+     files.  The root user may also alter the quota limits through sysctl files
+     (see the section "New procfs files").

 
      Process-specific and thread-specific keyrings are not counted towards a
      user's quota.
 
      Process-specific and thread-specific keyrings are not counted towards a
      user's quota.


@@ -329,6 +333,27 @@ about the status of the key service:
        <bytes>/<max>           Key size quota
 
 
        <bytes>/<max>           Key size quota
 
 

+Four new sysctl files have been added also for the purpose of controlling the
+quota limits on keys:
+
+ (*) /proc/sys/kernel/keys/root_maxkeys
+     /proc/sys/kernel/keys/root_maxbytes
+
+     These files hold the maximum number of keys that root may have and the
+     maximum total number of bytes of data that root may have stored in those
+     keys.
+
+ (*) /proc/sys/kernel/keys/maxkeys
+     /proc/sys/kernel/keys/maxbytes
+
+     These files hold the maximum number of keys that each non-root user may
+     have and the maximum total number of bytes of data that each of those
+     users may have stored in their keys.
+
+Root may alter these by writing each new limit as a decimal number string to
+the appropriate file.
+
+

 ===============================
 USERSPACE SYSTEM CALL INTERFACE
 ===============================
 ===============================
 USERSPACE SYSTEM CALL INTERFACE
 ===============================


@@ -711,6 +736,47 @@ The keyctl syscall functions are:
      The assumed authoritative key is inherited across fork and exec.
 
 
      The assumed authoritative key is inherited across fork and exec.
 
 

+ (*) Get the LSM security context attached to a key.
+
+       long keyctl(KEYCTL_GET_SECURITY, key_serial_t key, char *buffer,
+                   size_t buflen)
+
+     This function returns a string that represents the LSM security context
+     attached to a key in the buffer provided.
+
+     Unless there's an error, it always returns the amount of data it could
+     produce, even if that's too big for the buffer, but it won't copy more
+     than requested to userspace. If the buffer pointer is NULL then no copy
+     will take place.
+
+     A NUL character is included at the end of the string if the buffer is
+     sufficiently big.  This is included in the returned count.  If no LSM is
+     in force then an empty string will be returned.
+
+     A process must have view permission on the key for this function to be
+     successful.
+
+
+ (*) Install the calling process's session keyring on its parent.
+
+       long keyctl(KEYCTL_SESSION_TO_PARENT);
+
+     This functions attempts to install the calling process's session keyring
+     on to the calling process's parent, replacing the parent's current session
+     keyring.
+
+     The calling process must have the same ownership as its parent, the
+     keyring must have the same ownership as the calling process, the calling
+     process must have LINK permission on the keyring and the active LSM module
+     mustn't deny permission, otherwise error EPERM will be returned.
+
+     Error ENOMEM will be returned if there was insufficient memory to complete
+     the operation, otherwise 0 will be returned to indicate success.
+
+     The keyring will be replaced next time the parent process leaves the
+     kernel and resumes executing userspace.
+
+

 ===============
 KERNEL SERVICES
 ===============
 ===============
 KERNEL SERVICES
 ===============


@@ -726,6 +792,15 @@ call, and the key released upon close. How to deal with conflicting keys due to
 two different users opening the same file is left to the filesystem author to
 solve.
 
 two different users opening the same file is left to the filesystem author to
 solve.
 

+To access the key manager, the following header must be #included:
+
+       <linux/key.h>
+
+Specific key types should have a header file under include/keys/ that should be
+used to access that type.  For keys of type "user", for example, that would be:
+
+       <keys/user-type.h>
+

 Note that there are two different types of pointers to keys that may be
 encountered:
 
 Note that there are two different types of pointers to keys that may be
 encountered:
 


@@ -762,7 +837,7 @@ payload contents" for more information.
 
        struct key *request_key(const struct key_type *type,
                                const char *description,
 
        struct key *request_key(const struct key_type *type,
                                const char *description,

-                               const char *callout_string);
+                               const char *callout_info);

 
     This is used to request a key or keyring with a description that matches
     the description specified according to the key type's match function. This
 
     This is used to request a key or keyring with a description that matches
     the description specified according to the key type's match function. This


@@ -784,11 +859,45 @@ payload contents" for more information.
 
        struct key *request_key_with_auxdata(const struct key_type *type,
                                             const char *description,
 
        struct key *request_key_with_auxdata(const struct key_type *type,
                                             const char *description,

-                                            const char *callout_string,
+                                            const void *callout_info,
+                                            size_t callout_len,

                                             void *aux);
 
     This is identical to request_key(), except that the auxiliary data is
                                             void *aux);
 
     This is identical to request_key(), except that the auxiliary data is

-    passed to the key_type->request_key() op if it exists.
+    passed to the key_type->request_key() op if it exists, and the callout_info
+    is a blob of length callout_len, if given (the length may be 0).
+
+
+(*) A key can be requested asynchronously by calling one of:
+
+       struct key *request_key_async(const struct key_type *type,
+                                     const char *description,
+                                     const void *callout_info,
+                                     size_t callout_len);
+
+    or:
+
+       struct key *request_key_async_with_auxdata(const struct key_type *type,
+                                                  const char *description,
+                                                  const char *callout_info,
+                                                  size_t callout_len,
+                                                  void *aux);
+
+    which are asynchronous equivalents of request_key() and
+    request_key_with_auxdata() respectively.
+
+    These two functions return with the key potentially still under
+    construction.  To wait for construction completion, the following should be
+    called:
+
+       int wait_for_key_construction(struct key *key, bool intr);
+
+    The function will wait for the key to finish being constructed and then
+    invokes key_validate() to return an appropriate value to indicate the state
+    of the key (0 indicates the key is usable).
+
+    If intr is true, then the wait can be interrupted by a signal, in which
+    case error ERESTARTSYS will be returned.

 
 
 (*) When it is no longer required, the key should be released using:
 
 
 (*) When it is no longer required, the key should be released using:


@@ -924,7 +1033,11 @@ DEFINING A KEY TYPE
 
 A kernel service may want to define its own key type. For instance, an AFS
 filesystem might want to define a Kerberos 5 ticket key type. To do this, it
 
 A kernel service may want to define its own key type. For instance, an AFS
 filesystem might want to define a Kerberos 5 ticket key type. To do this, it

-author fills in a struct key_type and registers it with the system.
+author fills in a key_type struct and registers it with the system.
+
+Source files that implement key types should include the following header file:
+
+       <linux/key-type.h>

 
 The structure has a number of fields, some of which are mandatory:
 
 
 The structure has a number of fields, some of which are mandatory:
 


@@ -1053,22 +1166,44 @@ The structure has a number of fields, some of which are mandatory:
      as might happen when the userspace buffer is accessed.
 
 
      as might happen when the userspace buffer is accessed.
 
 

- (*) int (*request_key)(struct key *key, struct key *authkey, const char *op,
+ (*) int (*request_key)(struct key_construction *cons, const char *op,

                        void *aux);
 
                        void *aux);
 

-     This method is optional.  If provided, request_key() and
-     request_key_with_auxdata() will invoke this function rather than
-     upcalling to /sbin/request-key to operate upon a key of this type.
+     This method is optional.  If provided, request_key() and friends will
+     invoke this function rather than upcalling to /sbin/request-key to operate
+     upon a key of this type.
+
+     The aux parameter is as passed to request_key_async_with_auxdata() and
+     similar or is NULL otherwise.  Also passed are the construction record for
+     the key to be operated upon and the operation type (currently only
+     "create").
+
+     This method is permitted to return before the upcall is complete, but the
+     following function must be called under all circumstances to complete the
+     instantiation process, whether or not it succeeds, whether or not there's
+     an error:
+
+       void complete_request_key(struct key_construction *cons, int error);
+
+     The error parameter should be 0 on success, -ve on error.  The
+     construction record is destroyed by this action and the authorisation key
+     will be revoked.  If an error is indicated, the key under construction
+     will be negatively instantiated if it wasn't already instantiated.
+
+     If this method returns an error, that error will be returned to the
+     caller of request_key*().  complete_request_key() must be called prior to
+     returning.
+
+     The key under construction and the authorisation key can be found in the
+     key_construction struct pointed to by cons:

 
 

-     The aux parameter is as passed to request_key_with_auxdata() or is NULL
-     otherwise.  Also passed are the key to be operated upon, the
-     authorisation key for this operation and the operation type (currently
-     only "create").
+     (*) struct key *key;

 
 

-     This function should return only when the upcall is complete.  Upon return
-     the authorisation key will be revoked, and the target key will be
-     negatively instantiated if it is still uninstantiated.  The error will be
-     returned to the caller of request_key*().
+        The key under construction.
+
+     (*) struct key *authkey;
+
+        The authorisation key.

 
 
 ============================
 
 
 ============================


@@ -1119,3 +1254,17 @@ by executing:
 
 In this case, the program isn't required to actually attach the key to a ring;
 the rings are provided for reference.
 
 In this case, the program isn't required to actually attach the key to a ring;
 the rings are provided for reference.

+
+
+==================
+GARBAGE COLLECTION
+==================
+
+Dead keys (for which the type has been removed) will be automatically unlinked
+from those keyrings that point to them and deleted as soon as possible by a
+background garbage collector.
+
+Similarly, revoked and expired keys will be garbage collected, but only after a
+certain amount of time has passed.  This time is set as a number of seconds in:
+
+       /proc/sys/kernel/keys/gc_delay