8 files changed, 48 insertions, 70 deletions

diff --git a/security/keys/internal.h b/security/keys/internal.h
index 479909b858c7..8f533c81aa8d 100644
--- a/security/keys/internal.h
+++ b/security/keys/internal.h
@@ -186,20 +186,9 @@ static inline int key_permission(const key_ref_t key_ref, unsigned perm)
         return key_task_permission(key_ref, current_cred(), perm);
 }
 
-/*
- * Authorisation record for request_key().
- */
-struct request_key_auth {
-        struct key              *target_key;
-        struct key              *dest_keyring;
-        const struct cred       *cred;
-        void                    *callout_info;
-        size_t                  callout_len;
-        pid_t                   pid;
-} __randomize_layout;
-
 extern struct key_type key_type_request_key_auth;
 extern struct key *request_key_auth_new(struct key *target,
+                                        const char *op,
                                         const void *callout_info,
                                         size_t callout_len,
                                         struct key *dest_keyring);
diff --git a/security/keys/key.c b/security/keys/key.c
index 44a80d6741a1..696f1c092c50 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -265,8 +265,8 @@ struct key *key_alloc(struct key_type *type, const char *desc,
 
                 spin_lock(&user->lock);
                 if (!(flags & KEY_ALLOC_QUOTA_OVERRUN)) {
-                        if (user->qnkeys + 1 >= maxkeys ||
-                            user->qnbytes + quotalen >= maxbytes ||
+                        if (user->qnkeys + 1 > maxkeys ||
+                            user->qnbytes + quotalen > maxbytes ||
                             user->qnbytes + quotalen < user->qnbytes)
                                 goto no_quota;
                 }
@@ -297,6 +297,7 @@ struct key *key_alloc(struct key_type *type, const char *desc,
         key->gid = gid;
         key->perm = perm;
         key->restrict_link = restrict_link;
+        key->last_used_at = ktime_get_real_seconds();
 
         if (!(flags & KEY_ALLOC_NOT_IN_QUOTA))
                 key->flags |= 1 << KEY_FLAG_IN_QUOTA;
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index e8093d025966..7bbe03593e58 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -25,6 +25,7 @@
 #include <linux/security.h>
 #include <linux/uio.h>
 #include <linux/uaccess.h>
+#include <keys/request_key_auth-type.h>
 #include "internal.h"
 
 #define KEY_MAX_DESC_SIZE 4096
diff --git a/security/keys/keyring.c b/security/keys/keyring.c
index eadebb92986a..f81372f53dd7 100644
--- a/security/keys/keyring.c
+++ b/security/keys/keyring.c
@@ -661,9 +661,6 @@ static bool search_nested_keyrings(struct key *keyring,
         BUG_ON((ctx->flags & STATE_CHECKS) == 0 ||
                (ctx->flags & STATE_CHECKS) == STATE_CHECKS);
 
-        if (ctx->index_key.description)
-                ctx->index_key.desc_len = strlen(ctx->index_key.description);
-
         /* Check to see if this top-level keyring is what we are looking for
          * and whether it is valid or not.
          */
@@ -914,6 +911,7 @@ key_ref_t keyring_search(key_ref_t keyring,
         struct keyring_search_context ctx = {
                 .index_key.type         = type,
                 .index_key.description  = description,
+                .index_key.desc_len     = strlen(description),
                 .cred                   = current_cred(),
                 .match_data.cmp         = key_default_cmp,
                 .match_data.raw_data    = description,
diff --git a/security/keys/proc.c b/security/keys/proc.c
index d2b802072693..78ac305d715e 100644
--- a/security/keys/proc.c
+++ b/security/keys/proc.c
@@ -165,8 +165,7 @@ static int proc_keys_show(struct seq_file *m, void *v)
         int rc;
 
         struct keyring_search_context ctx = {
-                .index_key.type         = key->type,
-                .index_key.description  = key->description,
+                .index_key              = key->index_key,
                 .cred                   = m->file->f_cred,
                 .match_data.cmp         = lookup_user_key_possessed,
                 .match_data.raw_data    = key,
diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c
index 02c77e928f68..0e0b9ccad2f8 100644
--- a/security/keys/process_keys.c
+++ b/security/keys/process_keys.c
@@ -19,6 +19,7 @@
 #include <linux/security.h>
 #include <linux/user_namespace.h>
 #include <linux/uaccess.h>
+#include <keys/request_key_auth-type.h>
 #include "internal.h"
 
 /* Session keyring create vs join semaphore */
diff --git a/security/keys/request_key.c b/security/keys/request_key.c
index 301f0e300dbd..7a0c6b666ff0 100644
--- a/security/keys/request_key.c
+++ b/security/keys/request_key.c
@@ -18,31 +18,30 @@
 #include <linux/keyctl.h>
 #include <linux/slab.h>
 #include "internal.h"
+#include <keys/request_key_auth-type.h>
 
 #define key_negative_timeout    60      /* default timeout on a negative key's existence */
 
 /**
  * complete_request_key - Complete the construction of a key.
- * @cons: The key construction record.
+ * @auth_key: The authorisation key.
  * @error: The success or failute of the construction.
  *
  * Complete the attempt to construct a key.  The key will be negated
  * if an error is indicated.  The authorisation key will be revoked
  * unconditionally.
  */
-void complete_request_key(struct key_construction *cons, int error)
+void complete_request_key(struct key *authkey, int error)
 {
-        kenter("{%d,%d},%d", cons->key->serial, cons->authkey->serial, error);
+        struct request_key_auth *rka = get_request_key_auth(authkey);
+        struct key *key = rka->target_key;
+
+        kenter("%d{%d},%d", authkey->serial, key->serial, error);
 
         if (error < 0)
-                key_negate_and_link(cons->key, key_negative_timeout, NULL,
-                                    cons->authkey);
+                key_negate_and_link(key, key_negative_timeout, NULL, authkey);
         else
-                key_revoke(cons->authkey);
-
-        key_put(cons->key);
-        key_put(cons->authkey);
-        kfree(cons);
+                key_revoke(authkey);
 }
 EXPORT_SYMBOL(complete_request_key);
 
@@ -91,21 +90,19 @@ static int call_usermodehelper_keys(const char *path, char **argv, char **envp,
  * Request userspace finish the construction of a key
  * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
  */
-static int call_sbin_request_key(struct key_construction *cons,
-                                 const char *op,
-                                 void *aux)
+static int call_sbin_request_key(struct key *authkey, void *aux)
 {
         static char const request_key[] = "/sbin/request-key";
+        struct request_key_auth *rka = get_request_key_auth(authkey);
         const struct cred *cred = current_cred();
         key_serial_t prkey, sskey;
-        struct key *key = cons->key, *authkey = cons->authkey, *keyring,
-                *session;
+        struct key *key = rka->target_key, *keyring, *session;
         char *argv[9], *envp[3], uid_str[12], gid_str[12];
         char key_str[12], keyring_str[3][12];
         char desc[20];
         int ret, i;
 
-        kenter("{%d},{%d},%s", key->serial, authkey->serial, op);
+        kenter("{%d},{%d},%s", key->serial, authkey->serial, rka->op);
 
         ret = install_user_keyrings();
         if (ret < 0)
@@ -163,7 +160,7 @@ static int call_sbin_request_key(struct key_construction *cons,
         /* set up the argument list */
         i = 0;
         argv[i++] = (char *)request_key;
-        argv[i++] = (char *) op;
+        argv[i++] = (char *)rka->op;
         argv[i++] = key_str;
         argv[i++] = uid_str;
         argv[i++] = gid_str;
@@ -191,7 +188,7 @@ error_link:
         key_put(keyring);
 
 error_alloc:
-        complete_request_key(cons, ret);
+        complete_request_key(authkey, ret);
         kleave(" = %d", ret);
         return ret;
 }
@@ -205,42 +202,31 @@ static int construct_key(struct key *key, const void *callout_info,
                          size_t callout_len, void *aux,
                          struct key *dest_keyring)
 {
-        struct key_construction *cons;
         request_key_actor_t actor;
         struct key *authkey;
         int ret;
 
         kenter("%d,%p,%zu,%p", key->serial, callout_info, callout_len, aux);
 
-        cons = kmalloc(sizeof(*cons), GFP_KERNEL);
-        if (!cons)
-                return -ENOMEM;
-
         /* allocate an authorisation key */
-        authkey = request_key_auth_new(key, callout_info, callout_len,
+        authkey = request_key_auth_new(key, "create", callout_info, callout_len,
                                        dest_keyring);
-        if (IS_ERR(authkey)) {
-                kfree(cons);
-                ret = PTR_ERR(authkey);
-                authkey = NULL;
-        } else {
-                cons->authkey = key_get(authkey);
-                cons->key = key_get(key);
+        if (IS_ERR(authkey))
+                return PTR_ERR(authkey);
 
-                /* make the call */
-                actor = call_sbin_request_key;
-                if (key->type->request_key)
-                        actor = key->type->request_key;
+        /* Make the call */
+        actor = call_sbin_request_key;
+        if (key->type->request_key)
+                actor = key->type->request_key;
 
-                ret = actor(cons, "create", aux);
+        ret = actor(authkey, aux);
 
-                /* check that the actor called complete_request_key() prior to
-                 * returning an error */
-                WARN_ON(ret < 0 &&
-                        !test_bit(KEY_FLAG_REVOKED, &authkey->flags));
-                key_put(authkey);
-        }
+        /* check that the actor called complete_request_key() prior to
+         * returning an error */
+        WARN_ON(ret < 0 &&
+                !test_bit(KEY_FLAG_REVOKED, &authkey->flags));
 
+        key_put(authkey);
         kleave(" = %d", ret);
         return ret;
 }
@@ -275,7 +261,7 @@ static int construct_get_dest_keyring(struct key **_dest_keyring)
                         if (cred->request_key_auth) {
                                 authkey = cred->request_key_auth;
                                 down_read(&authkey->sem);
-                                rka = authkey->payload.data[0];
+                                rka = get_request_key_auth(authkey);
                                 if (!test_bit(KEY_FLAG_REVOKED,
                                               &authkey->flags))
                                         dest_keyring =
@@ -545,6 +531,7 @@ struct key *request_key_and_link(struct key_type *type,
         struct keyring_search_context ctx = {
                 .index_key.type         = type,
                 .index_key.description  = description,
+                .index_key.desc_len     = strlen(description),
                 .cred                   = current_cred(),
                 .match_data.cmp         = key_default_cmp,
                 .match_data.raw_data    = description,
diff --git a/security/keys/request_key_auth.c b/security/keys/request_key_auth.c
index 87ea2f54dedc..bda6201c6c45 100644
--- a/security/keys/request_key_auth.c
+++ b/security/keys/request_key_auth.c
@@ -17,7 +17,7 @@
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include "internal.h"
-#include <keys/user-type.h>
+#include <keys/request_key_auth-type.h>
 
 static int request_key_auth_preparse(struct key_preparsed_payload *);
 static void request_key_auth_free_preparse(struct key_preparsed_payload *);
@@ -68,7 +68,7 @@ static int request_key_auth_instantiate(struct key *key,
 static void request_key_auth_describe(const struct key *key,
                                       struct seq_file *m)
 {
-        struct request_key_auth *rka = key->payload.data[0];
+        struct request_key_auth *rka = get_request_key_auth(key);
 
         seq_puts(m, "key:");
         seq_puts(m, key->description);
@@ -83,7 +83,7 @@ static void request_key_auth_describe(const struct key *key,
 static long request_key_auth_read(const struct key *key,
                                   char __user *buffer, size_t buflen)
 {
-        struct request_key_auth *rka = key->payload.data[0];
+        struct request_key_auth *rka = get_request_key_auth(key);
         size_t datalen;
         long ret;
 
@@ -109,7 +109,7 @@ static long request_key_auth_read(const struct key *key,
  */
 static void request_key_auth_revoke(struct key *key)
 {
-        struct request_key_auth *rka = key->payload.data[0];
+        struct request_key_auth *rka = get_request_key_auth(key);
 
         kenter("{%d}", key->serial);
 
@@ -136,7 +136,7 @@ static void free_request_key_auth(struct request_key_auth *rka)
  */
 static void request_key_auth_destroy(struct key *key)
 {
-        struct request_key_auth *rka = key->payload.data[0];
+        struct request_key_auth *rka = get_request_key_auth(key);
 
         kenter("{%d}", key->serial);
 
@@ -147,8 +147,9 @@ static void request_key_auth_destroy(struct key *key)
  * Create an authorisation token for /sbin/request-key or whoever to gain
  * access to the caller's security data.
  */
-struct key *request_key_auth_new(struct key *target, const void *callout_info,
-                                 size_t callout_len, struct key *dest_keyring)
+struct key *request_key_auth_new(struct key *target, const char *op,
+                                 const void *callout_info, size_t callout_len,
+                                 struct key *dest_keyring)
 {
         struct request_key_auth *rka, *irka;
         const struct cred *cred = current->cred;
@@ -166,6 +167,7 @@ struct key *request_key_auth_new(struct key *target, const void *callout_info,
         if (!rka->callout_info)
                 goto error_free_rka;
         rka->callout_len = callout_len;
+        strlcpy(rka->op, op, sizeof(rka->op));
 
         /* see if the calling process is already servicing the key request of
          * another process */
@@ -245,7 +247,7 @@ struct key *key_get_instantiation_authkey(key_serial_t target_id)
         struct key *authkey;
         key_ref_t authkey_ref;
 
-        sprintf(description, "%x", target_id);
+        ctx.index_key.desc_len = sprintf(description, "%x", target_id);
 
         authkey_ref = search_process_keyrings(&ctx);