Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

17 files changed, 3419 insertions, 694 deletions

diff --git a/security/keys/Makefile b/security/keys/Makefile
index 74d5447d7df7..1bf090a885fe 100644
--- a/security/keys/Makefile
+++ b/security/keys/Makefile
@@ -13,6 +13,8 @@ obj-y := \
         request_key_auth.o \
         user_defined.o
 
+obj-$(CONFIG_TRUSTED_KEYS) += trusted.o
+obj-$(CONFIG_ENCRYPTED_KEYS) += encrypted.o
 obj-$(CONFIG_KEYS_COMPAT) += compat.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_SYSCTL) += sysctl.o
diff --git a/security/keys/compat.c b/security/keys/compat.c
index 792c0a611a6d..338b510e9027 100644
--- a/security/keys/compat.c
+++ b/security/keys/compat.c
@@ -1,4 +1,4 @@
-/* compat.c: 32-bit compatibility syscall for 64-bit systems
+/* 32-bit compatibility syscall for 64-bit systems
  *
  * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -12,15 +12,58 @@
 #include <linux/syscalls.h>
 #include <linux/keyctl.h>
 #include <linux/compat.h>
+#include <linux/slab.h>
 #include "internal.h"
 
-/*****************************************************************************/
 /*
- * the key control system call, 32-bit compatibility version for 64-bit archs
- * - this should only be called if the 64-bit arch uses weird pointers in
- *   32-bit mode or doesn't guarantee that the top 32-bits of the argument
- *   registers on taking a 32-bit syscall are zero
- * - if you can, you should call sys_keyctl directly
+ * Instantiate a key with the specified compatibility multipart payload and
+ * link the key into the destination keyring if one is given.
+ *
+ * The caller must have the appropriate instantiation permit set for this to
+ * work (see keyctl_assume_authority).  No other permissions are required.
+ *
+ * If successful, 0 will be returned.
+ */
+long compat_keyctl_instantiate_key_iov(
+        key_serial_t id,
+        const struct compat_iovec __user *_payload_iov,
+        unsigned ioc,
+        key_serial_t ringid)
+{
+        struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
+        long ret;
+
+        if (_payload_iov == 0 || ioc == 0)
+                goto no_payload;
+
+        ret = compat_rw_copy_check_uvector(WRITE, _payload_iov, ioc,
+                                           ARRAY_SIZE(iovstack),
+                                           iovstack, &iov);
+        if (ret < 0)
+                return ret;
+        if (ret == 0)
+                goto no_payload_free;
+
+        ret = keyctl_instantiate_key_common(id, iov, ioc, ret, ringid);
+
+        if (iov != iovstack)
+                kfree(iov);
+        return ret;
+
+no_payload_free:
+        if (iov != iovstack)
+                kfree(iov);
+no_payload:
+        return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid);
+}
+
+/*
+ * The key control system call, 32-bit compatibility version for 64-bit archs
+ *
+ * This should only be called if the 64-bit arch uses weird pointers in 32-bit
+ * mode or doesn't guarantee that the top 32-bits of the argument registers on
+ * taking a 32-bit syscall are zero.  If you can, you should call sys_keyctl()
+ * directly.
  */
 asmlinkage long compat_sys_keyctl(u32 option,
                                   u32 arg2, u32 arg3, u32 arg4, u32 arg5)
@@ -85,8 +128,14 @@ asmlinkage long compat_sys_keyctl(u32 option,
         case KEYCTL_SESSION_TO_PARENT:
                 return keyctl_session_to_parent();
 
+        case KEYCTL_REJECT:
+                return keyctl_reject_key(arg2, arg3, arg4, arg5);
+
+        case KEYCTL_INSTANTIATE_IOV:
+                return compat_keyctl_instantiate_key_iov(
+                        arg2, compat_ptr(arg3), arg4, arg5);
+
         default:
                 return -EOPNOTSUPP;
         }
-
-} /* end compat_sys_keyctl() */
+}
diff --git a/security/keys/encrypted.c b/security/keys/encrypted.c
new file mode 100644
index 000000000000..b1cba5bf0a5e
--- /dev/null
+++ b/security/keys/encrypted.c
@@ -0,0 +1,902 @@
+/*
+ * Copyright (C) 2010 IBM Corporation
+ *
+ * Author:
+ * Mimi Zohar <zohar@us.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * See Documentation/security/keys-trusted-encrypted.txt
+ */
+
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/parser.h>
+#include <linux/string.h>
+#include <linux/err.h>
+#include <keys/user-type.h>
+#include <keys/trusted-type.h>
+#include <keys/encrypted-type.h>
+#include <linux/key-type.h>
+#include <linux/random.h>
+#include <linux/rcupdate.h>
+#include <linux/scatterlist.h>
+#include <linux/crypto.h>
+#include <crypto/hash.h>
+#include <crypto/sha.h>
+#include <crypto/aes.h>
+
+#include "encrypted.h"
+
+static const char KEY_TRUSTED_PREFIX[] = "trusted:";
+static const char KEY_USER_PREFIX[] = "user:";
+static const char hash_alg[] = "sha256";
+static const char hmac_alg[] = "hmac(sha256)";
+static const char blkcipher_alg[] = "cbc(aes)";
+static unsigned int ivsize;
+static int blksize;
+
+#define KEY_TRUSTED_PREFIX_LEN (sizeof (KEY_TRUSTED_PREFIX) - 1)
+#define KEY_USER_PREFIX_LEN (sizeof (KEY_USER_PREFIX) - 1)
+#define HASH_SIZE SHA256_DIGEST_SIZE
+#define MAX_DATA_SIZE 4096
+#define MIN_DATA_SIZE  20
+
+struct sdesc {
+        struct shash_desc shash;
+        char ctx[];
+};
+
+static struct crypto_shash *hashalg;
+static struct crypto_shash *hmacalg;
+
+enum {
+        Opt_err = -1, Opt_new, Opt_load, Opt_update
+};
+
+static const match_table_t key_tokens = {
+        {Opt_new, "new"},
+        {Opt_load, "load"},
+        {Opt_update, "update"},
+        {Opt_err, NULL}
+};
+
+static int aes_get_sizes(void)
+{
+        struct crypto_blkcipher *tfm;
+
+        tfm = crypto_alloc_blkcipher(blkcipher_alg, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(tfm)) {
+                pr_err("encrypted_key: failed to alloc_cipher (%ld)\n",
+                       PTR_ERR(tfm));
+                return PTR_ERR(tfm);
+        }
+        ivsize = crypto_blkcipher_ivsize(tfm);
+        blksize = crypto_blkcipher_blocksize(tfm);
+        crypto_free_blkcipher(tfm);
+        return 0;
+}
+
+/*
+ * valid_master_desc - verify the 'key-type:desc' of a new/updated master-key
+ *
+ * key-type:= "trusted:" | "encrypted:"
+ * desc:= master-key description
+ *
+ * Verify that 'key-type' is valid and that 'desc' exists. On key update,
+ * only the master key description is permitted to change, not the key-type.
+ * The key-type remains constant.
+ *
+ * On success returns 0, otherwise -EINVAL.
+ */
+static int valid_master_desc(const char *new_desc, const char *orig_desc)
+{
+        if (!memcmp(new_desc, KEY_TRUSTED_PREFIX, KEY_TRUSTED_PREFIX_LEN)) {
+                if (strlen(new_desc) == KEY_TRUSTED_PREFIX_LEN)
+                        goto out;
+                if (orig_desc)
+                        if (memcmp(new_desc, orig_desc, KEY_TRUSTED_PREFIX_LEN))
+                                goto out;
+        } else if (!memcmp(new_desc, KEY_USER_PREFIX, KEY_USER_PREFIX_LEN)) {
+                if (strlen(new_desc) == KEY_USER_PREFIX_LEN)
+                        goto out;
+                if (orig_desc)
+                        if (memcmp(new_desc, orig_desc, KEY_USER_PREFIX_LEN))
+                                goto out;
+        } else
+                goto out;
+        return 0;
+out:
+        return -EINVAL;
+}
+
+/*
+ * datablob_parse - parse the keyctl data
+ *
+ * datablob format:
+ * new <master-key name> <decrypted data length>
+ * load <master-key name> <decrypted data length> <encrypted iv + data>
+ * update <new-master-key name>
+ *
+ * Tokenizes a copy of the keyctl data, returning a pointer to each token,
+ * which is null terminated.
+ *
+ * On success returns 0, otherwise -EINVAL.
+ */
+static int datablob_parse(char *datablob, char **master_desc,
+                          char **decrypted_datalen, char **hex_encoded_iv)
+{
+        substring_t args[MAX_OPT_ARGS];
+        int ret = -EINVAL;
+        int key_cmd;
+        char *p;
+
+        p = strsep(&datablob, " \t");
+        if (!p)
+                return ret;
+        key_cmd = match_token(p, key_tokens, args);
+
+        *master_desc = strsep(&datablob, " \t");
+        if (!*master_desc)
+                goto out;
+
+        if (valid_master_desc(*master_desc, NULL) < 0)
+                goto out;
+
+        if (decrypted_datalen) {
+                *decrypted_datalen = strsep(&datablob, " \t");
+                if (!*decrypted_datalen)
+                        goto out;
+        }
+
+        switch (key_cmd) {
+        case Opt_new:
+                if (!decrypted_datalen)
+                        break;
+                ret = 0;
+                break;
+        case Opt_load:
+                if (!decrypted_datalen)
+                        break;
+                *hex_encoded_iv = strsep(&datablob, " \t");
+                if (!*hex_encoded_iv)
+                        break;
+                ret = 0;
+                break;
+        case Opt_update:
+                if (decrypted_datalen)
+                        break;
+                ret = 0;
+                break;
+        case Opt_err:
+                break;
+        }
+out:
+        return ret;
+}
+
+/*
+ * datablob_format - format as an ascii string, before copying to userspace
+ */
+static char *datablob_format(struct encrypted_key_payload *epayload,
+                             size_t asciiblob_len)
+{
+        char *ascii_buf, *bufp;
+        u8 *iv = epayload->iv;
+        int len;
+        int i;
+
+        ascii_buf = kmalloc(asciiblob_len + 1, GFP_KERNEL);
+        if (!ascii_buf)
+                goto out;
+
+        ascii_buf[asciiblob_len] = '\0';
+
+        /* copy datablob master_desc and datalen strings */
+        len = sprintf(ascii_buf, "%s %s ", epayload->master_desc,
+                      epayload->datalen);
+
+        /* convert the hex encoded iv, encrypted-data and HMAC to ascii */
+        bufp = &ascii_buf[len];
+        for (i = 0; i < (asciiblob_len - len) / 2; i++)
+                bufp = pack_hex_byte(bufp, iv[i]);
+out:
+        return ascii_buf;
+}
+
+/*
+ * request_trusted_key - request the trusted key
+ *
+ * Trusted keys are sealed to PCRs and other metadata. Although userspace
+ * manages both trusted/encrypted key-types, like the encrypted key type
+ * data, trusted key type data is not visible decrypted from userspace.
+ */
+static struct key *request_trusted_key(const char *trusted_desc,
+                                       u8 **master_key, size_t *master_keylen)
+{
+        struct trusted_key_payload *tpayload;
+        struct key *tkey;
+
+        tkey = request_key(&key_type_trusted, trusted_desc, NULL);
+        if (IS_ERR(tkey))
+                goto error;
+
+        down_read(&tkey->sem);
+        tpayload = rcu_dereference(tkey->payload.data);
+        *master_key = tpayload->key;
+        *master_keylen = tpayload->key_len;
+error:
+        return tkey;
+}
+
+/*
+ * request_user_key - request the user key
+ *
+ * Use a user provided key to encrypt/decrypt an encrypted-key.
+ */
+static struct key *request_user_key(const char *master_desc, u8 **master_key,
+                                    size_t *master_keylen)
+{
+        struct user_key_payload *upayload;
+        struct key *ukey;
+
+        ukey = request_key(&key_type_user, master_desc, NULL);
+        if (IS_ERR(ukey))
+                goto error;
+
+        down_read(&ukey->sem);
+        upayload = rcu_dereference(ukey->payload.data);
+        *master_key = upayload->data;
+        *master_keylen = upayload->datalen;
+error:
+        return ukey;
+}
+
+static struct sdesc *alloc_sdesc(struct crypto_shash *alg)
+{
+        struct sdesc *sdesc;
+        int size;
+
+        size = sizeof(struct shash_desc) + crypto_shash_descsize(alg);
+        sdesc = kmalloc(size, GFP_KERNEL);
+        if (!sdesc)
+                return ERR_PTR(-ENOMEM);
+        sdesc->shash.tfm = alg;
+        sdesc->shash.flags = 0x0;
+        return sdesc;
+}
+
+static int calc_hmac(u8 *digest, const u8 *key, unsigned int keylen,
+                     const u8 *buf, unsigned int buflen)
+{
+        struct sdesc *sdesc;
+        int ret;
+
+        sdesc = alloc_sdesc(hmacalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("encrypted_key: can't alloc %s\n", hmac_alg);
+                return PTR_ERR(sdesc);
+        }
+
+        ret = crypto_shash_setkey(hmacalg, key, keylen);
+        if (!ret)
+                ret = crypto_shash_digest(&sdesc->shash, buf, buflen, digest);
+        kfree(sdesc);
+        return ret;
+}
+
+static int calc_hash(u8 *digest, const u8 *buf, unsigned int buflen)
+{
+        struct sdesc *sdesc;
+        int ret;
+
+        sdesc = alloc_sdesc(hashalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("encrypted_key: can't alloc %s\n", hash_alg);
+                return PTR_ERR(sdesc);
+        }
+
+        ret = crypto_shash_digest(&sdesc->shash, buf, buflen, digest);
+        kfree(sdesc);
+        return ret;
+}
+
+enum derived_key_type { ENC_KEY, AUTH_KEY };
+
+/* Derive authentication/encryption key from trusted key */
+static int get_derived_key(u8 *derived_key, enum derived_key_type key_type,
+                           const u8 *master_key, size_t master_keylen)
+{
+        u8 *derived_buf;
+        unsigned int derived_buf_len;
+        int ret;
+
+        derived_buf_len = strlen("AUTH_KEY") + 1 + master_keylen;
+        if (derived_buf_len < HASH_SIZE)
+                derived_buf_len = HASH_SIZE;
+
+        derived_buf = kzalloc(derived_buf_len, GFP_KERNEL);
+        if (!derived_buf) {
+                pr_err("encrypted_key: out of memory\n");
+                return -ENOMEM;
+        }
+        if (key_type)
+                strcpy(derived_buf, "AUTH_KEY");
+        else
+                strcpy(derived_buf, "ENC_KEY");
+
+        memcpy(derived_buf + strlen(derived_buf) + 1, master_key,
+               master_keylen);
+        ret = calc_hash(derived_key, derived_buf, derived_buf_len);
+        kfree(derived_buf);
+        return ret;
+}
+
+static int init_blkcipher_desc(struct blkcipher_desc *desc, const u8 *key,
+                               unsigned int key_len, const u8 *iv,
+                               unsigned int ivsize)
+{
+        int ret;
+
+        desc->tfm = crypto_alloc_blkcipher(blkcipher_alg, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(desc->tfm)) {
+                pr_err("encrypted_key: failed to load %s transform (%ld)\n",
+                       blkcipher_alg, PTR_ERR(desc->tfm));
+                return PTR_ERR(desc->tfm);
+        }
+        desc->flags = 0;
+
+        ret = crypto_blkcipher_setkey(desc->tfm, key, key_len);
+        if (ret < 0) {
+                pr_err("encrypted_key: failed to setkey (%d)\n", ret);
+                crypto_free_blkcipher(desc->tfm);
+                return ret;
+        }
+        crypto_blkcipher_set_iv(desc->tfm, iv, ivsize);
+        return 0;
+}
+
+static struct key *request_master_key(struct encrypted_key_payload *epayload,
+                                      u8 **master_key, size_t *master_keylen)
+{
+        struct key *mkey = NULL;
+
+        if (!strncmp(epayload->master_desc, KEY_TRUSTED_PREFIX,
+                     KEY_TRUSTED_PREFIX_LEN)) {
+                mkey = request_trusted_key(epayload->master_desc +
+                                           KEY_TRUSTED_PREFIX_LEN,
+                                           master_key, master_keylen);
+        } else if (!strncmp(epayload->master_desc, KEY_USER_PREFIX,
+                            KEY_USER_PREFIX_LEN)) {
+                mkey = request_user_key(epayload->master_desc +
+                                        KEY_USER_PREFIX_LEN,
+                                        master_key, master_keylen);
+        } else
+                goto out;
+
+        if (IS_ERR(mkey))
+                pr_info("encrypted_key: key %s not found",
+                        epayload->master_desc);
+        if (mkey)
+                dump_master_key(*master_key, *master_keylen);
+out:
+        return mkey;
+}
+
+/* Before returning data to userspace, encrypt decrypted data. */
+static int derived_key_encrypt(struct encrypted_key_payload *epayload,
+                               const u8 *derived_key,
+                               unsigned int derived_keylen)
+{
+        struct scatterlist sg_in[2];
+        struct scatterlist sg_out[1];
+        struct blkcipher_desc desc;
+        unsigned int encrypted_datalen;
+        unsigned int padlen;
+        char pad[16];
+        int ret;
+
+        encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);
+        padlen = encrypted_datalen - epayload->decrypted_datalen;
+
+        ret = init_blkcipher_desc(&desc, derived_key, derived_keylen,
+                                  epayload->iv, ivsize);
+        if (ret < 0)
+                goto out;
+        dump_decrypted_data(epayload);
+
+        memset(pad, 0, sizeof pad);
+        sg_init_table(sg_in, 2);
+        sg_set_buf(&sg_in[0], epayload->decrypted_data,
+                   epayload->decrypted_datalen);
+        sg_set_buf(&sg_in[1], pad, padlen);
+
+        sg_init_table(sg_out, 1);
+        sg_set_buf(sg_out, epayload->encrypted_data, encrypted_datalen);
+
+        ret = crypto_blkcipher_encrypt(&desc, sg_out, sg_in, encrypted_datalen);
+        crypto_free_blkcipher(desc.tfm);
+        if (ret < 0)
+                pr_err("encrypted_key: failed to encrypt (%d)\n", ret);
+        else
+                dump_encrypted_data(epayload, encrypted_datalen);
+out:
+        return ret;
+}
+
+static int datablob_hmac_append(struct encrypted_key_payload *epayload,
+                                const u8 *master_key, size_t master_keylen)
+{
+        u8 derived_key[HASH_SIZE];
+        u8 *digest;
+        int ret;
+
+        ret = get_derived_key(derived_key, AUTH_KEY, master_key, master_keylen);
+        if (ret < 0)
+                goto out;
+
+        digest = epayload->master_desc + epayload->datablob_len;
+        ret = calc_hmac(digest, derived_key, sizeof derived_key,
+                        epayload->master_desc, epayload->datablob_len);
+        if (!ret)
+                dump_hmac(NULL, digest, HASH_SIZE);
+out:
+        return ret;
+}
+
+/* verify HMAC before decrypting encrypted key */
+static int datablob_hmac_verify(struct encrypted_key_payload *epayload,
+                                const u8 *master_key, size_t master_keylen)
+{
+        u8 derived_key[HASH_SIZE];
+        u8 digest[HASH_SIZE];
+        int ret;
+
+        ret = get_derived_key(derived_key, AUTH_KEY, master_key, master_keylen);
+        if (ret < 0)
+                goto out;
+
+        ret = calc_hmac(digest, derived_key, sizeof derived_key,
+                        epayload->master_desc, epayload->datablob_len);
+        if (ret < 0)
+                goto out;
+        ret = memcmp(digest, epayload->master_desc + epayload->datablob_len,
+                     sizeof digest);
+        if (ret) {
+                ret = -EINVAL;
+                dump_hmac("datablob",
+                          epayload->master_desc + epayload->datablob_len,
+                          HASH_SIZE);
+                dump_hmac("calc", digest, HASH_SIZE);
+        }
+out:
+        return ret;
+}
+
+static int derived_key_decrypt(struct encrypted_key_payload *epayload,
+                               const u8 *derived_key,
+                               unsigned int derived_keylen)
+{
+        struct scatterlist sg_in[1];
+        struct scatterlist sg_out[2];
+        struct blkcipher_desc desc;
+        unsigned int encrypted_datalen;
+        char pad[16];
+        int ret;
+
+        encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);
+        ret = init_blkcipher_desc(&desc, derived_key, derived_keylen,
+                                  epayload->iv, ivsize);
+        if (ret < 0)
+                goto out;
+        dump_encrypted_data(epayload, encrypted_datalen);
+
+        memset(pad, 0, sizeof pad);
+        sg_init_table(sg_in, 1);
+        sg_init_table(sg_out, 2);
+        sg_set_buf(sg_in, epayload->encrypted_data, encrypted_datalen);
+        sg_set_buf(&sg_out[0], epayload->decrypted_data,
+                   epayload->decrypted_datalen);
+        sg_set_buf(&sg_out[1], pad, sizeof pad);
+
+        ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, encrypted_datalen);
+        crypto_free_blkcipher(desc.tfm);
+        if (ret < 0)
+                goto out;
+        dump_decrypted_data(epayload);
+out:
+        return ret;
+}
+
+/* Allocate memory for decrypted key and datablob. */
+static struct encrypted_key_payload *encrypted_key_alloc(struct key *key,
+                                                         const char *master_desc,
+                                                         const char *datalen)
+{
+        struct encrypted_key_payload *epayload = NULL;
+        unsigned short datablob_len;
+        unsigned short decrypted_datalen;
+        unsigned int encrypted_datalen;
+        long dlen;
+        int ret;
+
+        ret = strict_strtol(datalen, 10, &dlen);
+        if (ret < 0 || dlen < MIN_DATA_SIZE || dlen > MAX_DATA_SIZE)
+                return ERR_PTR(-EINVAL);
+
+        decrypted_datalen = dlen;
+        encrypted_datalen = roundup(decrypted_datalen, blksize);
+
+        datablob_len = strlen(master_desc) + 1 + strlen(datalen) + 1
+            + ivsize + 1 + encrypted_datalen;
+
+        ret = key_payload_reserve(key, decrypted_datalen + datablob_len
+                                  + HASH_SIZE + 1);
+        if (ret < 0)
+                return ERR_PTR(ret);
+
+        epayload = kzalloc(sizeof(*epayload) + decrypted_datalen +
+                           datablob_len + HASH_SIZE + 1, GFP_KERNEL);
+        if (!epayload)
+                return ERR_PTR(-ENOMEM);
+
+        epayload->decrypted_datalen = decrypted_datalen;
+        epayload->datablob_len = datablob_len;
+        return epayload;
+}
+
+static int encrypted_key_decrypt(struct encrypted_key_payload *epayload,
+                                 const char *hex_encoded_iv)
+{
+        struct key *mkey;
+        u8 derived_key[HASH_SIZE];
+        u8 *master_key;
+        u8 *hmac;
+        const char *hex_encoded_data;
+        unsigned int encrypted_datalen;
+        size_t master_keylen;
+        size_t asciilen;
+        int ret;
+
+        encrypted_datalen = roundup(epayload->decrypted_datalen, blksize);
+        asciilen = (ivsize + 1 + encrypted_datalen + HASH_SIZE) * 2;
+        if (strlen(hex_encoded_iv) != asciilen)
+                return -EINVAL;
+
+        hex_encoded_data = hex_encoded_iv + (2 * ivsize) + 2;
+        hex2bin(epayload->iv, hex_encoded_iv, ivsize);
+        hex2bin(epayload->encrypted_data, hex_encoded_data, encrypted_datalen);
+
+        hmac = epayload->master_desc + epayload->datablob_len;
+        hex2bin(hmac, hex_encoded_data + (encrypted_datalen * 2), HASH_SIZE);
+
+        mkey = request_master_key(epayload, &master_key, &master_keylen);
+        if (IS_ERR(mkey))
+                return PTR_ERR(mkey);
+
+        ret = datablob_hmac_verify(epayload, master_key, master_keylen);
+        if (ret < 0) {
+                pr_err("encrypted_key: bad hmac (%d)\n", ret);
+                goto out;
+        }
+
+        ret = get_derived_key(derived_key, ENC_KEY, master_key, master_keylen);
+        if (ret < 0)
+                goto out;
+
+        ret = derived_key_decrypt(epayload, derived_key, sizeof derived_key);
+        if (ret < 0)
+                pr_err("encrypted_key: failed to decrypt key (%d)\n", ret);
+out:
+        up_read(&mkey->sem);
+        key_put(mkey);
+        return ret;
+}
+
+static void __ekey_init(struct encrypted_key_payload *epayload,
+                        const char *master_desc, const char *datalen)
+{
+        epayload->master_desc = epayload->decrypted_data
+            + epayload->decrypted_datalen;
+        epayload->datalen = epayload->master_desc + strlen(master_desc) + 1;
+        epayload->iv = epayload->datalen + strlen(datalen) + 1;
+        epayload->encrypted_data = epayload->iv + ivsize + 1;
+
+        memcpy(epayload->master_desc, master_desc, strlen(master_desc));
+        memcpy(epayload->datalen, datalen, strlen(datalen));
+}
+
+/*
+ * encrypted_init - initialize an encrypted key
+ *
+ * For a new key, use a random number for both the iv and data
+ * itself.  For an old key, decrypt the hex encoded data.
+ */
+static int encrypted_init(struct encrypted_key_payload *epayload,
+                          const char *master_desc, const char *datalen,
+                          const char *hex_encoded_iv)
+{
+        int ret = 0;
+
+        __ekey_init(epayload, master_desc, datalen);
+        if (!hex_encoded_iv) {
+                get_random_bytes(epayload->iv, ivsize);
+
+                get_random_bytes(epayload->decrypted_data,
+                                 epayload->decrypted_datalen);
+        } else
+                ret = encrypted_key_decrypt(epayload, hex_encoded_iv);
+        return ret;
+}
+
+/*
+ * encrypted_instantiate - instantiate an encrypted key
+ *
+ * Decrypt an existing encrypted datablob or create a new encrypted key
+ * based on a kernel random number.
+ *
+ * On success, return 0. Otherwise return errno.
+ */
+static int encrypted_instantiate(struct key *key, const void *data,
+                                 size_t datalen)
+{
+        struct encrypted_key_payload *epayload = NULL;
+        char *datablob = NULL;
+        char *master_desc = NULL;
+        char *decrypted_datalen = NULL;
+        char *hex_encoded_iv = NULL;
+        int ret;
+
+        if (datalen <= 0 || datalen > 32767 || !data)
+                return -EINVAL;
+
+        datablob = kmalloc(datalen + 1, GFP_KERNEL);
+        if (!datablob)
+                return -ENOMEM;
+        datablob[datalen] = 0;
+        memcpy(datablob, data, datalen);
+        ret = datablob_parse(datablob, &master_desc, &decrypted_datalen,
+                             &hex_encoded_iv);
+        if (ret < 0)
+                goto out;
+
+        epayload = encrypted_key_alloc(key, master_desc, decrypted_datalen);
+        if (IS_ERR(epayload)) {
+                ret = PTR_ERR(epayload);
+                goto out;
+        }
+        ret = encrypted_init(epayload, master_desc, decrypted_datalen,
+                             hex_encoded_iv);
+        if (ret < 0) {
+                kfree(epayload);
+                goto out;
+        }
+
+        rcu_assign_pointer(key->payload.data, epayload);
+out:
+        kfree(datablob);
+        return ret;
+}
+
+static void encrypted_rcu_free(struct rcu_head *rcu)
+{
+        struct encrypted_key_payload *epayload;
+
+        epayload = container_of(rcu, struct encrypted_key_payload, rcu);
+        memset(epayload->decrypted_data, 0, epayload->decrypted_datalen);
+        kfree(epayload);
+}
+
+/*
+ * encrypted_update - update the master key description
+ *
+ * Change the master key description for an existing encrypted key.
+ * The next read will return an encrypted datablob using the new
+ * master key description.
+ *
+ * On success, return 0. Otherwise return errno.
+ */
+static int encrypted_update(struct key *key, const void *data, size_t datalen)
+{
+        struct encrypted_key_payload *epayload = key->payload.data;
+        struct encrypted_key_payload *new_epayload;
+        char *buf;
+        char *new_master_desc = NULL;
+        int ret = 0;
+
+        if (datalen <= 0 || datalen > 32767 || !data)
+                return -EINVAL;
+
+        buf = kmalloc(datalen + 1, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        buf[datalen] = 0;
+        memcpy(buf, data, datalen);
+        ret = datablob_parse(buf, &new_master_desc, NULL, NULL);
+        if (ret < 0)
+                goto out;
+
+        ret = valid_master_desc(new_master_desc, epayload->master_desc);
+        if (ret < 0)
+                goto out;
+
+        new_epayload = encrypted_key_alloc(key, new_master_desc,
+                                           epayload->datalen);
+        if (IS_ERR(new_epayload)) {
+                ret = PTR_ERR(new_epayload);
+                goto out;
+        }
+
+        __ekey_init(new_epayload, new_master_desc, epayload->datalen);
+
+        memcpy(new_epayload->iv, epayload->iv, ivsize);
+        memcpy(new_epayload->decrypted_data, epayload->decrypted_data,
+               epayload->decrypted_datalen);
+
+        rcu_assign_pointer(key->payload.data, new_epayload);
+        call_rcu(&epayload->rcu, encrypted_rcu_free);
+out:
+        kfree(buf);
+        return ret;
+}
+
+/*
+ * encrypted_read - format and copy the encrypted data to userspace
+ *
+ * The resulting datablob format is:
+ * <master-key name> <decrypted data length> <encrypted iv> <encrypted data>
+ *
+ * On success, return to userspace the encrypted key datablob size.
+ */
+static long encrypted_read(const struct key *key, char __user *buffer,
+                           size_t buflen)
+{
+        struct encrypted_key_payload *epayload;
+        struct key *mkey;
+        u8 *master_key;
+        size_t master_keylen;
+        char derived_key[HASH_SIZE];
+        char *ascii_buf;
+        size_t asciiblob_len;
+        int ret;
+
+        epayload = rcu_dereference_key(key);
+
+        /* returns the hex encoded iv, encrypted-data, and hmac as ascii */
+        asciiblob_len = epayload->datablob_len + ivsize + 1
+            + roundup(epayload->decrypted_datalen, blksize)
+            + (HASH_SIZE * 2);
+
+        if (!buffer || buflen < asciiblob_len)
+                return asciiblob_len;
+
+        mkey = request_master_key(epayload, &master_key, &master_keylen);
+        if (IS_ERR(mkey))
+                return PTR_ERR(mkey);
+
+        ret = get_derived_key(derived_key, ENC_KEY, master_key, master_keylen);
+        if (ret < 0)
+                goto out;
+
+        ret = derived_key_encrypt(epayload, derived_key, sizeof derived_key);
+        if (ret < 0)
+                goto out;
+
+        ret = datablob_hmac_append(epayload, master_key, master_keylen);
+        if (ret < 0)
+                goto out;
+
+        ascii_buf = datablob_format(epayload, asciiblob_len);
+        if (!ascii_buf) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        up_read(&mkey->sem);
+        key_put(mkey);
+
+        if (copy_to_user(buffer, ascii_buf, asciiblob_len) != 0)
+                ret = -EFAULT;
+        kfree(ascii_buf);
+
+        return asciiblob_len;
+out:
+        up_read(&mkey->sem);
+        key_put(mkey);
+        return ret;
+}
+
+/*
+ * encrypted_destroy - before freeing the key, clear the decrypted data
+ *
+ * Before freeing the key, clear the memory containing the decrypted
+ * key data.
+ */
+static void encrypted_destroy(struct key *key)
+{
+        struct encrypted_key_payload *epayload = key->payload.data;
+
+        if (!epayload)
+                return;
+
+        memset(epayload->decrypted_data, 0, epayload->decrypted_datalen);
+        kfree(key->payload.data);
+}
+
+struct key_type key_type_encrypted = {
+        .name = "encrypted",
+        .instantiate = encrypted_instantiate,
+        .update = encrypted_update,
+        .match = user_match,
+        .destroy = encrypted_destroy,
+        .describe = user_describe,
+        .read = encrypted_read,
+};
+EXPORT_SYMBOL_GPL(key_type_encrypted);
+
+static void encrypted_shash_release(void)
+{
+        if (hashalg)
+                crypto_free_shash(hashalg);
+        if (hmacalg)
+                crypto_free_shash(hmacalg);
+}
+
+static int __init encrypted_shash_alloc(void)
+{
+        int ret;
+
+        hmacalg = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(hmacalg)) {
+                pr_info("encrypted_key: could not allocate crypto %s\n",
+                        hmac_alg);
+                return PTR_ERR(hmacalg);
+        }
+
+        hashalg = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(hashalg)) {
+                pr_info("encrypted_key: could not allocate crypto %s\n",
+                        hash_alg);
+                ret = PTR_ERR(hashalg);
+                goto hashalg_fail;
+        }
+
+        return 0;
+
+hashalg_fail:
+        crypto_free_shash(hmacalg);
+        return ret;
+}
+
+static int __init init_encrypted(void)
+{
+        int ret;
+
+        ret = encrypted_shash_alloc();
+        if (ret < 0)
+                return ret;
+        ret = register_key_type(&key_type_encrypted);
+        if (ret < 0)
+                goto out;
+        return aes_get_sizes();
+out:
+        encrypted_shash_release();
+        return ret;
+
+}
+
+static void __exit cleanup_encrypted(void)
+{
+        encrypted_shash_release();
+        unregister_key_type(&key_type_encrypted);
+}
+
+late_initcall(init_encrypted);
+module_exit(cleanup_encrypted);
+
+MODULE_LICENSE("GPL");
diff --git a/security/keys/encrypted.h b/security/keys/encrypted.h
new file mode 100644
index 000000000000..cef5e2f2b7d1
--- /dev/null
+++ b/security/keys/encrypted.h
@@ -0,0 +1,54 @@
+#ifndef __ENCRYPTED_KEY_H
+#define __ENCRYPTED_KEY_H
+
+#define ENCRYPTED_DEBUG 0
+
+#if ENCRYPTED_DEBUG
+static inline void dump_master_key(const u8 *master_key, size_t master_keylen)
+{
+        print_hex_dump(KERN_ERR, "master key: ", DUMP_PREFIX_NONE, 32, 1,
+                       master_key, master_keylen, 0);
+}
+
+static inline void dump_decrypted_data(struct encrypted_key_payload *epayload)
+{
+        print_hex_dump(KERN_ERR, "decrypted data: ", DUMP_PREFIX_NONE, 32, 1,
+                       epayload->decrypted_data,
+                       epayload->decrypted_datalen, 0);
+}
+
+static inline void dump_encrypted_data(struct encrypted_key_payload *epayload,
+                                       unsigned int encrypted_datalen)
+{
+        print_hex_dump(KERN_ERR, "encrypted data: ", DUMP_PREFIX_NONE, 32, 1,
+                       epayload->encrypted_data, encrypted_datalen, 0);
+}
+
+static inline void dump_hmac(const char *str, const u8 *digest,
+                             unsigned int hmac_size)
+{
+        if (str)
+                pr_info("encrypted_key: %s", str);
+        print_hex_dump(KERN_ERR, "hmac: ", DUMP_PREFIX_NONE, 32, 1, digest,
+                       hmac_size, 0);
+}
+#else
+static inline void dump_master_key(const u8 *master_key, size_t master_keylen)
+{
+}
+
+static inline void dump_decrypted_data(struct encrypted_key_payload *epayload)
+{
+}
+
+static inline void dump_encrypted_data(struct encrypted_key_payload *epayload,
+                                       unsigned int encrypted_datalen)
+{
+}
+
+static inline void dump_hmac(const char *str, const u8 *digest,
+                             unsigned int hmac_size)
+{
+}
+#endif
+#endif
diff --git a/security/keys/gc.c b/security/keys/gc.c
index a46e825cbf02..89df6b5f203c 100644
--- a/security/keys/gc.c
+++ b/security/keys/gc.c
@@ -32,8 +32,8 @@ static time_t key_gc_next_run = LONG_MAX;
 static time_t key_gc_new_timer;
 
 /*
- * Schedule a garbage collection run
- * - precision isn't particularly important
+ * Schedule a garbage collection run.
+ * - time precision isn't particularly important
  */
 void key_schedule_gc(time_t gc_at)
 {
@@ -61,8 +61,9 @@ static void key_gc_timer_func(unsigned long data)
 }
 
 /*
- * Garbage collect pointers from a keyring
- * - return true if we altered the keyring
+ * Garbage collect pointers from a keyring.
+ *
+ * Return true if we altered the keyring.
  */
 static bool key_gc_keyring(struct key *keyring, time_t limit)
         __releases(key_serial_lock)
@@ -107,9 +108,8 @@ do_gc:
 }
 
 /*
- * Garbage collector for keys
- * - this involves scanning the keyrings for dead, expired and revoked keys
- *   that have overstayed their welcome
+ * Garbage collector for keys.  This involves scanning the keyrings for dead,
+ * expired and revoked keys that have overstayed their welcome
  */
 static void key_garbage_collector(struct work_struct *work)
 {
diff --git a/security/keys/internal.h b/security/keys/internal.h
index 56a133d8f37d..f375152a2500 100644
--- a/security/keys/internal.h
+++ b/security/keys/internal.h
@@ -1,4 +1,4 @@
-/* internal.h: authentication token and access key management internal defs
+/* Authentication token and access key management internal defs
  *
  * Copyright (C) 2003-5, 2007 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -35,10 +35,12 @@ extern struct key_type key_type_user;
 
 /*****************************************************************************/
 /*
- * keep track of keys for a user
- * - this needs to be separate to user_struct to avoid a refcount-loop
- *   (user_struct pins some keyrings which pin this struct)
- * - this also keeps track of keys under request from userspace for this UID
+ * Keep track of keys for a user.
+ *
+ * This needs to be separate to user_struct to avoid a refcount-loop
+ * (user_struct pins some keyrings which pin this struct).
+ *
+ * We also keep track of keys under request from userspace for this UID here.
  */
 struct key_user {
         struct rb_node          node;
@@ -62,7 +64,7 @@ extern struct key_user *key_user_lookup(uid_t uid,
 extern void key_user_put(struct key_user *user);
 
 /*
- * key quota limits
+ * Key quota limits.
  * - root has its own separate limits to everyone else
  */
 extern unsigned key_quota_root_maxkeys;
@@ -85,13 +87,13 @@ extern void key_type_put(struct key_type *ktype);
 extern int __key_link_begin(struct key *keyring,
                             const struct key_type *type,
                             const char *description,
-                            struct keyring_list **_prealloc);
+                            unsigned long *_prealloc);
 extern int __key_link_check_live_key(struct key *keyring, struct key *key);
 extern void __key_link(struct key *keyring, struct key *key,
-                       struct keyring_list **_prealloc);
+                       unsigned long *_prealloc);
 extern void __key_link_end(struct key *keyring,
                            struct key_type *type,
-                           struct keyring_list *prealloc);
+                           unsigned long prealloc);
 
 extern key_ref_t __keyring_search_one(key_ref_t keyring_ref,
                                       const struct key_type *type,
@@ -107,11 +109,13 @@ extern key_ref_t keyring_search_aux(key_ref_t keyring_ref,
                                     const struct cred *cred,
                                     struct key_type *type,
                                     const void *description,
-                                    key_match_func_t match);
+                                    key_match_func_t match,
+                                    bool no_state_check);
 
 extern key_ref_t search_my_process_keyrings(struct key_type *type,
                                             const void *description,
                                             key_match_func_t match,
+                                            bool no_state_check,
                                             const struct cred *cred);
 extern key_ref_t search_process_keyrings(struct key_type *type,
                                          const void *description,
@@ -146,13 +150,13 @@ extern unsigned key_gc_delay;
 extern void keyring_gc(struct key *keyring, time_t limit);
 extern void key_schedule_gc(time_t expiry_at);
 
-/*
- * check to see whether permission is granted to use a key in the desired way
- */
 extern int key_task_permission(const key_ref_t key_ref,
                                const struct cred *cred,
                                key_perm_t perm);
 
+/*
+ * Check to see whether permission is granted to use a key in the desired way.
+ */
 static inline int key_permission(const key_ref_t key_ref, key_perm_t perm)
 {
         return key_task_permission(key_ref, current_cred(), perm);
@@ -168,7 +172,7 @@ static inline int key_permission(const key_ref_t key_ref, key_perm_t perm)
 #define KEY_ALL         0x3f    /* all the above permissions */
 
 /*
- * request_key authorisation
+ * Authorisation record for request_key().
  */
 struct request_key_auth {
         struct key              *target_key;
@@ -188,7 +192,7 @@ extern struct key *request_key_auth_new(struct key *target,
 extern struct key *key_get_instantiation_authkey(key_serial_t target_id);
 
 /*
- * keyctl functions
+ * keyctl() functions
  */
 extern long keyctl_get_keyring_ID(key_serial_t, int);
 extern long keyctl_join_session_keyring(const char __user *);
@@ -212,9 +216,17 @@ extern long keyctl_assume_authority(key_serial_t);
 extern long keyctl_get_security(key_serial_t keyid, char __user *buffer,
                                 size_t buflen);
 extern long keyctl_session_to_parent(void);
+extern long keyctl_reject_key(key_serial_t, unsigned, unsigned, key_serial_t);
+extern long keyctl_instantiate_key_iov(key_serial_t,
+                                       const struct iovec __user *,
+                                       unsigned, key_serial_t);
+
+extern long keyctl_instantiate_key_common(key_serial_t,
+                                          const struct iovec __user *,
+                                          unsigned, size_t, key_serial_t);
 
 /*
- * debugging key validation
+ * Debugging key validation
  */
 #ifdef KEY_DEBUGGING
 extern void __key_check(const struct key *);
diff --git a/security/keys/key.c b/security/keys/key.c
index c1eac8084ade..f7f9d93f08d9 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -39,10 +39,10 @@ static DECLARE_RWSEM(key_types_sem);
 static void key_cleanup(struct work_struct *work);
 static DECLARE_WORK(key_cleanup_task, key_cleanup);
 
-/* we serialise key instantiation and link */
+/* We serialise key instantiation and link */
 DEFINE_MUTEX(key_construction_mutex);
 
-/* any key who's type gets unegistered will be re-typed to this */
+/* Any key who's type gets unegistered will be re-typed to this */
 static struct key_type key_type_dead = {
         .name           = "dead",
 };
@@ -56,10 +56,9 @@ void __key_check(const struct key *key)
 }
 #endif
 
-/*****************************************************************************/
 /*
- * get the key quota record for a user, allocating a new record if one doesn't
- * already exist
+ * Get the key quota record for a user, allocating a new record if one doesn't
+ * already exist.
  */
 struct key_user *key_user_lookup(uid_t uid, struct user_namespace *user_ns)
 {
@@ -67,7 +66,7 @@ struct key_user *key_user_lookup(uid_t uid, struct user_namespace *user_ns)
         struct rb_node *parent = NULL;
         struct rb_node **p;
 
- try_again:
+try_again:
         p = &key_user_tree.rb_node;
         spin_lock(&key_user_lock);
 
@@ -124,18 +123,16 @@ struct key_user *key_user_lookup(uid_t uid, struct user_namespace *user_ns)
         goto out;
 
         /* okay - we found a user record for this UID */
- found:
+found:
         atomic_inc(&user->usage);
         spin_unlock(&key_user_lock);
         kfree(candidate);
- out:
+out:
         return user;
+}
 
-} /* end key_user_lookup() */
-
-/*****************************************************************************/
 /*
- * dispose of a user structure
+ * Dispose of a user structure
  */
 void key_user_put(struct key_user *user)
 {
@@ -146,14 +143,11 @@ void key_user_put(struct key_user *user)
 
                 kfree(user);
         }
+}
 
-} /* end key_user_put() */
-
-/*****************************************************************************/
 /*
- * assign a key the next unique serial number
- * - these are assigned randomly to avoid security issues through covert
- *   channel problems
+ * Allocate a serial number for a key.  These are assigned randomly to avoid
+ * security issues through covert channel problems.
  */
 static inline void key_alloc_serial(struct key *key)
 {
@@ -211,18 +205,36 @@ serial_exists:
                 if (key->serial < xkey->serial)
                         goto attempt_insertion;
         }
+}
 
-} /* end key_alloc_serial() */
-
-/*****************************************************************************/
-/*
- * allocate a key of the specified type
- * - update the user's quota to reflect the existence of the key
- * - called from a key-type operation with key_types_sem read-locked by
- *   key_create_or_update()
- *   - this prevents unregistration of the key type
- * - upon return the key is as yet uninstantiated; the caller needs to either
- *   instantiate the key or discard it before returning
+/**
+ * key_alloc - Allocate a key of the specified type.
+ * @type: The type of key to allocate.
+ * @desc: The key description to allow the key to be searched out.
+ * @uid: The owner of the new key.
+ * @gid: The group ID for the new key's group permissions.
+ * @cred: The credentials specifying UID namespace.
+ * @perm: The permissions mask of the new key.
+ * @flags: Flags specifying quota properties.
+ *
+ * Allocate a key of the specified type with the attributes given.  The key is
+ * returned in an uninstantiated state and the caller needs to instantiate the
+ * key before returning.
+ *
+ * The user's key count quota is updated to reflect the creation of the key and
+ * the user's key data quota has the default for the key type reserved.  The
+ * instantiation function should amend this as necessary.  If insufficient
+ * quota is available, -EDQUOT will be returned.
+ *
+ * The LSM security modules can prevent a key being created, in which case
+ * -EACCES will be returned.
+ *
+ * Returns a pointer to the new key if successful and an error code otherwise.
+ *
+ * Note that the caller needs to ensure the key type isn't uninstantiated.
+ * Internally this can be done by locking key_types_sem.  Externally, this can
+ * be done by either never unregistering the key type, or making sure
+ * key_alloc() calls don't race with module unloading.
  */
 struct key *key_alloc(struct key_type *type, const char *desc,
                       uid_t uid, gid_t gid, const struct cred *cred,
@@ -237,6 +249,14 @@ struct key *key_alloc(struct key_type *type, const char *desc,
         if (!desc || !*desc)
                 goto error;
 
+        if (type->vet_description) {
+                ret = type->vet_description(desc);
+                if (ret < 0) {
+                        key = ERR_PTR(ret);
+                        goto error;
+                }
+        }
+
         desclen = strlen(desc) + 1;
         quotalen = desclen + type->def_datalen;
 
@@ -344,14 +364,19 @@ no_quota:
         key_user_put(user);
         key = ERR_PTR(-EDQUOT);
         goto error;
-
-} /* end key_alloc() */
-
+}
 EXPORT_SYMBOL(key_alloc);
 
-/*****************************************************************************/
-/*
- * reserve an amount of quota for the key's payload
+/**
+ * key_payload_reserve - Adjust data quota reservation for the key's payload
+ * @key: The key to make the reservation for.
+ * @datalen: The amount of data payload the caller now wants.
+ *
+ * Adjust the amount of the owning user's key data quota that a key reserves.
+ * If the amount is increased, then -EDQUOT may be returned if there isn't
+ * enough free quota available.
+ *
+ * If successful, 0 is returned.
  */
 int key_payload_reserve(struct key *key, size_t datalen)
 {
@@ -384,22 +409,21 @@ int key_payload_reserve(struct key *key, size_t datalen)
                 key->datalen = datalen;
 
         return ret;
-
-} /* end key_payload_reserve() */
-
+}
 EXPORT_SYMBOL(key_payload_reserve);
 
-/*****************************************************************************/
 /*
- * instantiate a key and link it into the target keyring atomically
- * - called with the target keyring's semaphore writelocked
+ * Instantiate a key and link it into the target keyring atomically.  Must be
+ * called with the target keyring's semaphore writelocked.  The target key's
+ * semaphore need not be locked as instantiation is serialised by
+ * key_construction_mutex.
  */
 static int __key_instantiate_and_link(struct key *key,
                                       const void *data,
                                       size_t datalen,
                                       struct key *keyring,
                                       struct key *authkey,
-                                      struct keyring_list **_prealloc)
+                                      unsigned long *_prealloc)
 {
         int ret, awaken;
 
@@ -441,12 +465,23 @@ static int __key_instantiate_and_link(struct key *key,
                 wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
 
         return ret;
+}
 
-} /* end __key_instantiate_and_link() */
-
-/*****************************************************************************/
-/*
- * instantiate a key and link it into the target keyring atomically
+/**
+ * key_instantiate_and_link - Instantiate a key and link it into the keyring.
+ * @key: The key to instantiate.
+ * @data: The data to use to instantiate the keyring.
+ * @datalen: The length of @data.
+ * @keyring: Keyring to create a link in on success (or NULL).
+ * @authkey: The authorisation token permitting instantiation.
+ *
+ * Instantiate a key that's in the uninstantiated state using the provided data
+ * and, if successful, link it in to the destination keyring if one is
+ * supplied.
+ *
+ * If successful, 0 is returned, the authorisation token is revoked and anyone
+ * waiting for the key is woken up.  If the key was already instantiated,
+ * -EBUSY will be returned.
  */
 int key_instantiate_and_link(struct key *key,
                              const void *data,
@@ -454,7 +489,7 @@ int key_instantiate_and_link(struct key *key,
                              struct key *keyring,
                              struct key *authkey)
 {
-        struct keyring_list *prealloc;
+        unsigned long prealloc;
         int ret;
 
         if (keyring) {
@@ -471,21 +506,38 @@ int key_instantiate_and_link(struct key *key,
                 __key_link_end(keyring, key->type, prealloc);
 
         return ret;
-
-} /* end key_instantiate_and_link() */
+}
 
 EXPORT_SYMBOL(key_instantiate_and_link);
 
-/*****************************************************************************/
-/*
- * negatively instantiate a key and link it into the target keyring atomically
+/**
+ * key_reject_and_link - Negatively instantiate a key and link it into the keyring.
+ * @key: The key to instantiate.
+ * @timeout: The timeout on the negative key.
+ * @error: The error to return when the key is hit.
+ * @keyring: Keyring to create a link in on success (or NULL).
+ * @authkey: The authorisation token permitting instantiation.
+ *
+ * Negatively instantiate a key that's in the uninstantiated state and, if
+ * successful, set its timeout and stored error and link it in to the
+ * destination keyring if one is supplied.  The key and any links to the key
+ * will be automatically garbage collected after the timeout expires.
+ *
+ * Negative keys are used to rate limit repeated request_key() calls by causing
+ * them to return the stored error code (typically ENOKEY) until the negative
+ * key expires.
+ *
+ * If successful, 0 is returned, the authorisation token is revoked and anyone
+ * waiting for the key is woken up.  If the key was already instantiated,
+ * -EBUSY will be returned.
  */
-int key_negate_and_link(struct key *key,
+int key_reject_and_link(struct key *key,
                         unsigned timeout,
+                        unsigned error,
                         struct key *keyring,
                         struct key *authkey)
 {
-        struct keyring_list *prealloc;
+        unsigned long prealloc;
         struct timespec now;
         int ret, awaken, link_ret = 0;
 
@@ -507,6 +559,7 @@ int key_negate_and_link(struct key *key,
                 atomic_inc(&key->user->nikeys);
                 set_bit(KEY_FLAG_NEGATIVE, &key->flags);
                 set_bit(KEY_FLAG_INSTANTIATED, &key->flags);
+                key->type_data.reject_error = -error;
                 now = current_kernel_time();
                 key->expiry = now.tv_sec + timeout;
                 key_schedule_gc(key->expiry + key_gc_delay);
@@ -535,22 +588,22 @@ int key_negate_and_link(struct key *key,
                 wake_up_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT);
 
         return ret == 0 ? link_ret : ret;
+}
+EXPORT_SYMBOL(key_reject_and_link);
 
-} /* end key_negate_and_link() */
-
-EXPORT_SYMBOL(key_negate_and_link);
-
-/*****************************************************************************/
 /*
- * do cleaning up in process context so that we don't have to disable
- * interrupts all over the place
+ * Garbage collect keys in process context so that we don't have to disable
+ * interrupts all over the place.
+ *
+ * key_put() schedules this rather than trying to do the cleanup itself, which
+ * means key_put() doesn't have to sleep.
  */
 static void key_cleanup(struct work_struct *work)
 {
         struct rb_node *_n;
         struct key *key;
 
- go_again:
+go_again:
         /* look for a dead key in the tree */
         spin_lock(&key_serial_lock);
 
@@ -564,7 +617,7 @@ static void key_cleanup(struct work_struct *work)
         spin_unlock(&key_serial_lock);
         return;
 
- found_dead_key:
+found_dead_key:
         /* we found a dead key - once we've removed it from the tree, we can
          * drop the lock */
         rb_erase(&key->serial_node, &key_serial_tree);
@@ -601,14 +654,15 @@ static void key_cleanup(struct work_struct *work)
 
         /* there may, of course, be more than one key to destroy */
         goto go_again;
+}
 
-} /* end key_cleanup() */
-
-/*****************************************************************************/
-/*
- * dispose of a reference to a key
- * - when all the references are gone, we schedule the cleanup task to come and
- *   pull it out of the tree in definite process context
+/**
+ * key_put - Discard a reference to a key.
+ * @key: The key to discard a reference from.
+ *
+ * Discard a reference to a key, and when all the references are gone, we
+ * schedule the cleanup task to come and pull it out of the tree in process
+ * context at some later time.
  */
 void key_put(struct key *key)
 {
@@ -618,14 +672,11 @@ void key_put(struct key *key)
                 if (atomic_dec_and_test(&key->usage))
                         schedule_work(&key_cleanup_task);
         }
-
-} /* end key_put() */
-
+}
 EXPORT_SYMBOL(key_put);
 
-/*****************************************************************************/
 /*
- * find a key by its serial number
+ * Find a key by its serial number.
  */
 struct key *key_lookup(key_serial_t id)
 {
@@ -647,11 +698,11 @@ struct key *key_lookup(key_serial_t id)
                         goto found;
         }
 
- not_found:
+not_found:
         key = ERR_PTR(-ENOKEY);
         goto error;
 
- found:
+found:
         /* pretend it doesn't exist if it is awaiting deletion */
         if (atomic_read(&key->usage) == 0)
                 goto not_found;
@@ -661,16 +712,16 @@ struct key *key_lookup(key_serial_t id)
          */
         atomic_inc(&key->usage);
 
- error:
+error:
         spin_unlock(&key_serial_lock);
         return key;
+}
 
-} /* end key_lookup() */
-
-/*****************************************************************************/
 /*
- * find and lock the specified key type against removal
- * - we return with the sem readlocked
+ * Find and lock the specified key type against removal.
+ *
+ * We return with the sem read-locked if successful.  If the type wasn't
+ * available -ENOKEY is returned instead.
  */
 struct key_type *key_type_lookup(const char *type)
 {
@@ -688,26 +739,23 @@ struct key_type *key_type_lookup(const char *type)
         up_read(&key_types_sem);
         ktype = ERR_PTR(-ENOKEY);
 
- found_kernel_type:
+found_kernel_type:
         return ktype;
+}
 
-} /* end key_type_lookup() */
-
-/*****************************************************************************/
 /*
- * unlock a key type
+ * Unlock a key type locked by key_type_lookup().
  */
 void key_type_put(struct key_type *ktype)
 {
         up_read(&key_types_sem);
+}
 
-} /* end key_type_put() */
-
-/*****************************************************************************/
 /*
- * attempt to update an existing key
- * - the key has an incremented refcount
- * - we need to put the key if we get an error
+ * Attempt to update an existing key.
+ *
+ * The key is given to us with an incremented refcount that we need to discard
+ * if we get an error.
  */
 static inline key_ref_t __key_update(key_ref_t key_ref,
                                      const void *payload, size_t plen)
@@ -742,13 +790,32 @@ error:
         key_put(key);
         key_ref = ERR_PTR(ret);
         goto out;
+}
 
-} /* end __key_update() */
-
-/*****************************************************************************/
-/*
- * search the specified keyring for a key of the same description; if one is
- * found, update it, otherwise add a new one
+/**
+ * key_create_or_update - Update or create and instantiate a key.
+ * @keyring_ref: A pointer to the destination keyring with possession flag.
+ * @type: The type of key.
+ * @description: The searchable description for the key.
+ * @payload: The data to use to instantiate or update the key.
+ * @plen: The length of @payload.
+ * @perm: The permissions mask for a new key.
+ * @flags: The quota flags for a new key.
+ *
+ * Search the destination keyring for a key of the same description and if one
+ * is found, update it, otherwise create and instantiate a new one and create a
+ * link to it from that keyring.
+ *
+ * If perm is KEY_PERM_UNDEF then an appropriate key permissions mask will be
+ * concocted.
+ *
+ * Returns a pointer to the new key if successful, -ENODEV if the key type
+ * wasn't available, -ENOTDIR if the keyring wasn't a keyring, -EACCES if the
+ * caller isn't permitted to modify the keyring or the LSM did not permit
+ * creation of the key.
+ *
+ * On success, the possession flag from the keyring ref will be tacked on to
+ * the key ref before it is returned.
  */
 key_ref_t key_create_or_update(key_ref_t keyring_ref,
                                const char *type,
@@ -758,7 +825,7 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
                                key_perm_t perm,
                                unsigned long flags)
 {
-        struct keyring_list *prealloc;
+        unsigned long prealloc;
         const struct cred *cred = current_cred();
         struct key_type *ktype;
         struct key *keyring, *key = NULL;
@@ -855,14 +922,21 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
 
         key_ref = __key_update(key_ref, payload, plen);
         goto error;
-
-} /* end key_create_or_update() */
-
+}
 EXPORT_SYMBOL(key_create_or_update);
 
-/*****************************************************************************/
-/*
- * update a key
+/**
+ * key_update - Update a key's contents.
+ * @key_ref: The pointer (plus possession flag) to the key.
+ * @payload: The data to be used to update the key.
+ * @plen: The length of @payload.
+ *
+ * Attempt to update the contents of a key with the given payload data.  The
+ * caller must be granted Write permission on the key.  Negative keys can be
+ * instantiated by this method.
+ *
+ * Returns 0 on success, -EACCES if not permitted and -EOPNOTSUPP if the key
+ * type does not support updating.  The key type may return other errors.
  */
 int key_update(key_ref_t key_ref, const void *payload, size_t plen)
 {
@@ -891,14 +965,17 @@ int key_update(key_ref_t key_ref, const void *payload, size_t plen)
 
  error:
         return ret;
-
-} /* end key_update() */
-
+}
 EXPORT_SYMBOL(key_update);
 
-/*****************************************************************************/
-/*
- * revoke a key
+/**
+ * key_revoke - Revoke a key.
+ * @key: The key to be revoked.
+ *
+ * Mark a key as being revoked and ask the type to free up its resources.  The
+ * revocation timeout is set and the key and all its links will be
+ * automatically garbage collected after key_gc_delay amount of time if they
+ * are not manually dealt with first.
  */
 void key_revoke(struct key *key)
 {
@@ -926,14 +1003,16 @@ void key_revoke(struct key *key)
         }
 
         up_write(&key->sem);
-
-} /* end key_revoke() */
-
+}
 EXPORT_SYMBOL(key_revoke);
 
-/*****************************************************************************/
-/*
- * register a type of key
+/**
+ * register_key_type - Register a type of key.
+ * @ktype: The new key type.
+ *
+ * Register a new key type.
+ *
+ * Returns 0 on success or -EEXIST if a type of this name already exists.
  */
 int register_key_type(struct key_type *ktype)
 {
@@ -953,17 +1032,19 @@ int register_key_type(struct key_type *ktype)
         list_add(&ktype->link, &key_types_list);
         ret = 0;
 
- out:
+out:
         up_write(&key_types_sem);
         return ret;
-
-} /* end register_key_type() */
-
+}
 EXPORT_SYMBOL(register_key_type);
 
-/*****************************************************************************/
-/*
- * unregister a type of key
+/**
+ * unregister_key_type - Unregister a type of key.
+ * @ktype: The key type.
+ *
+ * Unregister a key type and mark all the extant keys of this type as dead.
+ * Those keys of this type are then destroyed to get rid of their payloads and
+ * they and their links will be garbage collected as soon as possible.
  */
 void unregister_key_type(struct key_type *ktype)
 {
@@ -1010,14 +1091,11 @@ void unregister_key_type(struct key_type *ktype)
         up_write(&key_types_sem);
 
         key_schedule_gc(0);
-
-} /* end unregister_key_type() */
-
+}
 EXPORT_SYMBOL(unregister_key_type);
 
-/*****************************************************************************/
 /*
- * initialise the key management stuff
+ * Initialise the key management state.
  */
 void __init key_init(void)
 {
@@ -1037,5 +1115,4 @@ void __init key_init(void)
 
         rb_insert_color(&root_key_user.node,
                         &key_user_tree);
-
-} /* end key_init() */
+}
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index 60924f6a52db..eca51918c951 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -1,4 +1,4 @@
-/* keyctl.c: userspace keyctl operations
+/* Userspace key control operations
  *
  * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -31,28 +31,24 @@ static int key_get_type_from_user(char *type,
         int ret;
 
         ret = strncpy_from_user(type, _type, len);
-
         if (ret < 0)
                 return ret;
-
         if (ret == 0 || ret >= len)
                 return -EINVAL;
-
         if (type[0] == '.')
                 return -EPERM;
-
         type[len - 1] = '\0';
-
         return 0;
 }
 
-/*****************************************************************************/
 /*
- * extract the description of a new key from userspace and either add it as a
- * new key to the specified keyring or update a matching key in that keyring
- * - the keyring must be writable
- * - returns the new key's serial number
- * - implements add_key()
+ * Extract the description of a new key from userspace and either add it as a
+ * new key to the specified keyring or update a matching key in that keyring.
+ *
+ * The keyring must be writable so that we can attach the key to it.
+ *
+ * If successful, the new key's serial number is returned, otherwise an error
+ * code is returned.
  */
 SYSCALL_DEFINE5(add_key, const char __user *, _type,
                 const char __user *, _description,
@@ -132,19 +128,20 @@ SYSCALL_DEFINE5(add_key, const char __user *, _type,
         kfree(description);
  error:
         return ret;
+}
 
-} /* end sys_add_key() */
-
-/*****************************************************************************/
 /*
- * search the process keyrings for a matching key
- * - nested keyrings may also be searched if they have Search permission
- * - if a key is found, it will be attached to the destination keyring if
- *   there's one specified
- * - /sbin/request-key will be invoked if _callout_info is non-NULL
- *   - the _callout_info string will be passed to /sbin/request-key
- *   - if the _callout_info string is empty, it will be rendered as "-"
- * - implements request_key()
+ * Search the process keyrings and keyring trees linked from those for a
+ * matching key.  Keyrings must have appropriate Search permission to be
+ * searched.
+ *
+ * If a key is found, it will be attached to the destination keyring if there's
+ * one specified and the serial number of the key will be returned.
+ *
+ * If no key is found, /sbin/request-key will be invoked if _callout_info is
+ * non-NULL in an attempt to create a key.  The _callout_info string will be
+ * passed to /sbin/request-key to aid with completing the request.  If the
+ * _callout_info string is "" then it will be changed to "-".
  */
 SYSCALL_DEFINE4(request_key, const char __user *, _type,
                 const char __user *, _description,
@@ -209,8 +206,14 @@ SYSCALL_DEFINE4(request_key, const char __user *, _type,
                 goto error5;
         }
 
+        /* wait for the key to finish being constructed */
+        ret = wait_for_key_construction(key, 1);
+        if (ret < 0)
+                goto error6;
+
         ret = key->serial;
 
+error6:
         key_put(key);
 error5:
         key_type_put(ktype);
@@ -222,14 +225,14 @@ error2:
         kfree(description);
 error:
         return ret;
+}
 
-} /* end sys_request_key() */
-
-/*****************************************************************************/
 /*
- * get the ID of the specified process keyring
- * - the keyring must have search permission to be found
- * - implements keyctl(KEYCTL_GET_KEYRING_ID)
+ * Get the ID of the specified process keyring.
+ *
+ * The requested keyring must have search permission to be found.
+ *
+ * If successful, the ID of the requested keyring will be returned.
  */
 long keyctl_get_keyring_ID(key_serial_t id, int create)
 {
@@ -248,13 +251,17 @@ long keyctl_get_keyring_ID(key_serial_t id, int create)
         key_ref_put(key_ref);
 error:
         return ret;
+}
 
-} /* end keyctl_get_keyring_ID() */
-
-/*****************************************************************************/
 /*
- * join the session keyring
- * - implements keyctl(KEYCTL_JOIN_SESSION_KEYRING)
+ * Join a (named) session keyring.
+ *
+ * Create and join an anonymous session keyring or join a named session
+ * keyring, creating it if necessary.  A named session keyring must have Search
+ * permission for it to be joined.  Session keyrings without this permit will
+ * be skipped over.
+ *
+ * If successful, the ID of the joined session keyring will be returned.
  */
 long keyctl_join_session_keyring(const char __user *_name)
 {
@@ -277,14 +284,17 @@ long keyctl_join_session_keyring(const char __user *_name)
 
 error:
         return ret;
+}
 
-} /* end keyctl_join_session_keyring() */
-
-/*****************************************************************************/
 /*
- * update a key's data payload
- * - the key must be writable
- * - implements keyctl(KEYCTL_UPDATE)
+ * Update a key's data payload from the given data.
+ *
+ * The key must grant the caller Write permission and the key type must support
+ * updating for this to work.  A negative key can be positively instantiated
+ * with this call.
+ *
+ * If successful, 0 will be returned.  If the key type does not support
+ * updating, then -EOPNOTSUPP will be returned.
  */
 long keyctl_update_key(key_serial_t id,
                        const void __user *_payload,
@@ -326,14 +336,17 @@ error2:
         kfree(payload);
 error:
         return ret;
+}
 
-} /* end keyctl_update_key() */
-
-/*****************************************************************************/
 /*
- * revoke a key
- * - the key must be writable
- * - implements keyctl(KEYCTL_REVOKE)
+ * Revoke a key.
+ *
+ * The key must be grant the caller Write or Setattr permission for this to
+ * work.  The key type should give up its quota claim when revoked.  The key
+ * and any links to the key will be automatically garbage collected after a
+ * certain amount of time (/proc/sys/kernel/keys/gc_delay).
+ *
+ * If successful, 0 is returned.
  */
 long keyctl_revoke_key(key_serial_t id)
 {
@@ -358,14 +371,14 @@ long keyctl_revoke_key(key_serial_t id)
         key_ref_put(key_ref);
 error:
         return ret;
+}
 
-} /* end keyctl_revoke_key() */
-
-/*****************************************************************************/
 /*
- * clear the specified process keyring
- * - the keyring must be writable
- * - implements keyctl(KEYCTL_CLEAR)
+ * Clear the specified keyring, creating an empty process keyring if one of the
+ * special keyring IDs is used.
+ *
+ * The keyring must grant the caller Write permission for this to work.  If
+ * successful, 0 will be returned.
  */
 long keyctl_keyring_clear(key_serial_t ringid)
 {
@@ -383,15 +396,18 @@ long keyctl_keyring_clear(key_serial_t ringid)
         key_ref_put(keyring_ref);
 error:
         return ret;
+}
 
-} /* end keyctl_keyring_clear() */
-
-/*****************************************************************************/
 /*
- * link a key into a keyring
- * - the keyring must be writable
- * - the key must be linkable
- * - implements keyctl(KEYCTL_LINK)
+ * Create a link from a keyring to a key if there's no matching key in the
+ * keyring, otherwise replace the link to the matching key with a link to the
+ * new key.
+ *
+ * The key must grant the caller Link permission and the the keyring must grant
+ * the caller Write permission.  Furthermore, if an additional link is created,
+ * the keyring's quota will be extended.
+ *
+ * If successful, 0 will be returned.
  */
 long keyctl_keyring_link(key_serial_t id, key_serial_t ringid)
 {
@@ -417,15 +433,16 @@ error2:
         key_ref_put(keyring_ref);
 error:
         return ret;
+}
 
-} /* end keyctl_keyring_link() */
-
-/*****************************************************************************/
 /*
- * unlink the first attachment of a key from a keyring
- * - the keyring must be writable
- * - we don't need any permissions on the key
- * - implements keyctl(KEYCTL_UNLINK)
+ * Unlink a key from a keyring.
+ *
+ * The keyring must grant the caller Write permission for this to work; the key
+ * itself need not grant the caller anything.  If the last link to a key is
+ * removed then that key will be scheduled for destruction.
+ *
+ * If successful, 0 will be returned.
  */
 long keyctl_keyring_unlink(key_serial_t id, key_serial_t ringid)
 {
@@ -451,19 +468,20 @@ error2:
         key_ref_put(keyring_ref);
 error:
         return ret;
+}
 
-} /* end keyctl_keyring_unlink() */
-
-/*****************************************************************************/
 /*
- * describe a user key
- * - the key must have view permission
- * - if there's a buffer, we place up to buflen bytes of data into it
- * - unless there's an error, we return the amount of description available,
- *   irrespective of how much we may have copied
- * - the description is formatted thus:
+ * Return a description of a key to userspace.
+ *
+ * The key must grant the caller View permission for this to work.
+ *
+ * If there's a buffer, we place up to buflen bytes of data into it formatted
+ * in the following way:
+ *
  *      type;uid;gid;perm;description<NUL>
- * - implements keyctl(KEYCTL_DESCRIBE)
+ *
+ * If successful, we return the amount of description available, irrespective
+ * of how much we may have copied into the buffer.
  */
 long keyctl_describe_key(key_serial_t keyid,
                          char __user *buffer,
@@ -531,18 +549,17 @@ error2:
         key_ref_put(key_ref);
 error:
         return ret;
+}
 
-} /* end keyctl_describe_key() */
-
-/*****************************************************************************/
 /*
- * search the specified keyring for a matching key
- * - the start keyring must be searchable
- * - nested keyrings may also be searched if they are searchable
- * - only keys with search permission may be found
- * - if a key is found, it will be attached to the destination keyring if
- *   there's one specified
- * - implements keyctl(KEYCTL_SEARCH)
+ * Search the specified keyring and any keyrings it links to for a matching
+ * key.  Only keyrings that grant the caller Search permission will be searched
+ * (this includes the starting keyring).  Only keys with Search permission can
+ * be found.
+ *
+ * If successful, the found key will be linked to the destination keyring if
+ * supplied and the key has Link permission, and the found key ID will be
+ * returned.
  */
 long keyctl_keyring_search(key_serial_t ringid,
                            const char __user *_type,
@@ -626,18 +643,17 @@ error2:
         kfree(description);
 error:
         return ret;
+}
 
-} /* end keyctl_keyring_search() */
-
-/*****************************************************************************/
 /*
- * read a user key's payload
- * - the keyring must be readable or the key must be searchable from the
- *   process's keyrings
- * - if there's a buffer, we place up to buflen bytes of data into it
- * - unless there's an error, we return the amount of data in the key,
- *   irrespective of how much we may have copied
- * - implements keyctl(KEYCTL_READ)
+ * Read a key's payload.
+ *
+ * The key must either grant the caller Read permission, or it must grant the
+ * caller Search permission when searched for from the process keyrings.
+ *
+ * If successful, we place up to buflen bytes of data into the buffer, if one
+ * is provided, and return the amount of data that is available in the key,
+ * irrespective of how much we copied into the buffer.
  */
 long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen)
 {
@@ -688,15 +704,22 @@ error2:
         key_put(key);
 error:
         return ret;
+}
 
-} /* end keyctl_read_key() */
-
-/*****************************************************************************/
 /*
- * change the ownership of a key
- * - the keyring owned by the changer
- * - if the uid or gid is -1, then that parameter is not changed
- * - implements keyctl(KEYCTL_CHOWN)
+ * Change the ownership of a key
+ *
+ * The key must grant the caller Setattr permission for this to work, though
+ * the key need not be fully instantiated yet.  For the UID to be changed, or
+ * for the GID to be changed to a group the caller is not a member of, the
+ * caller must have sysadmin capability.  If either uid or gid is -1 then that
+ * attribute is not changed.
+ *
+ * If the UID is to be changed, the new user must have sufficient quota to
+ * accept the key.  The quota deduction will be removed from the old user to
+ * the new user should the attribute be changed.
+ *
+ * If successful, 0 will be returned.
  */
 long keyctl_chown_key(key_serial_t id, uid_t uid, gid_t gid)
 {
@@ -796,14 +819,14 @@ quota_overrun:
         zapowner = newowner;
         ret = -EDQUOT;
         goto error_put;
+}
 
-} /* end keyctl_chown_key() */
-
-/*****************************************************************************/
 /*
- * change the permission mask on a key
- * - the keyring owned by the changer
- * - implements keyctl(KEYCTL_SETPERM)
+ * Change the permission mask on a key.
+ *
+ * The key must grant the caller Setattr permission for this to work, though
+ * the key need not be fully instantiated yet.  If the caller does not have
+ * sysadmin capability, it may only change the permission on keys that it owns.
  */
 long keyctl_setperm_key(key_serial_t id, key_perm_t perm)
 {
@@ -838,11 +861,11 @@ long keyctl_setperm_key(key_serial_t id, key_perm_t perm)
         key_put(key);
 error:
         return ret;
-
-} /* end keyctl_setperm_key() */
+}
 
 /*
- * get the destination keyring for instantiation
+ * Get the destination keyring for instantiation and check that the caller has
+ * Write permission on it.
  */
 static long get_instantiation_keyring(key_serial_t ringid,
                                       struct request_key_auth *rka,
@@ -879,7 +902,7 @@ static long get_instantiation_keyring(key_serial_t ringid,
 }
 
 /*
- * change the request_key authorisation key on the current process
+ * Change the request_key authorisation key on the current process.
  */
 static int keyctl_change_reqkey_auth(struct key *key)
 {
@@ -895,15 +918,35 @@ static int keyctl_change_reqkey_auth(struct key *key)
         return commit_creds(new);
 }
 
-/*****************************************************************************/
 /*
- * instantiate the key with the specified payload, and, if one is given, link
- * the key into the keyring
+ * Copy the iovec data from userspace
  */
-long keyctl_instantiate_key(key_serial_t id,
-                            const void __user *_payload,
-                            size_t plen,
-                            key_serial_t ringid)
+static long copy_from_user_iovec(void *buffer, const struct iovec *iov,
+                                 unsigned ioc)
+{
+        for (; ioc > 0; ioc--) {
+                if (copy_from_user(buffer, iov->iov_base, iov->iov_len) != 0)
+                        return -EFAULT;
+                buffer += iov->iov_len;
+                iov++;
+        }
+        return 0;
+}
+
+/*
+ * Instantiate a key with the specified payload and link the key into the
+ * destination keyring if one is given.
+ *
+ * The caller must have the appropriate instantiation permit set for this to
+ * work (see keyctl_assume_authority).  No other permissions are required.
+ *
+ * If successful, 0 will be returned.
+ */
+long keyctl_instantiate_key_common(key_serial_t id,
+                                   const struct iovec *payload_iov,
+                                   unsigned ioc,
+                                   size_t plen,
+                                   key_serial_t ringid)
 {
         const struct cred *cred = current_cred();
         struct request_key_auth *rka;
@@ -932,7 +975,7 @@ long keyctl_instantiate_key(key_serial_t id,
         /* pull the payload in if one was supplied */
         payload = NULL;
 
-        if (_payload) {
+        if (payload_iov) {
                 ret = -ENOMEM;
                 payload = kmalloc(plen, GFP_KERNEL);
                 if (!payload) {
@@ -944,8 +987,8 @@ long keyctl_instantiate_key(key_serial_t id,
                                 goto error;
                 }
 
-                ret = -EFAULT;
-                if (copy_from_user(payload, _payload, plen) != 0)
+                ret = copy_from_user_iovec(payload, payload_iov, ioc);
+                if (ret < 0)
                         goto error2;
         }
 
@@ -973,22 +1016,127 @@ error2:
                 vfree(payload);
 error:
         return ret;
+}
+
+/*
+ * Instantiate a key with the specified payload and link the key into the
+ * destination keyring if one is given.
+ *
+ * The caller must have the appropriate instantiation permit set for this to
+ * work (see keyctl_assume_authority).  No other permissions are required.
+ *
+ * If successful, 0 will be returned.
+ */
+long keyctl_instantiate_key(key_serial_t id,
+                            const void __user *_payload,
+                            size_t plen,
+                            key_serial_t ringid)
+{
+        if (_payload && plen) {
+                struct iovec iov[1] = {
+                        [0].iov_base = (void __user *)_payload,
+                        [0].iov_len  = plen
+                };
 
-} /* end keyctl_instantiate_key() */
+                return keyctl_instantiate_key_common(id, iov, 1, plen, ringid);
+        }
+
+        return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid);
+}
 
-/*****************************************************************************/
 /*
- * negatively instantiate the key with the given timeout (in seconds), and, if
- * one is given, link the key into the keyring
+ * Instantiate a key with the specified multipart payload and link the key into
+ * the destination keyring if one is given.
+ *
+ * The caller must have the appropriate instantiation permit set for this to
+ * work (see keyctl_assume_authority).  No other permissions are required.
+ *
+ * If successful, 0 will be returned.
+ */
+long keyctl_instantiate_key_iov(key_serial_t id,
+                                const struct iovec __user *_payload_iov,
+                                unsigned ioc,
+                                key_serial_t ringid)
+{
+        struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
+        long ret;
+
+        if (_payload_iov == 0 || ioc == 0)
+                goto no_payload;
+
+        ret = rw_copy_check_uvector(WRITE, _payload_iov, ioc,
+                                    ARRAY_SIZE(iovstack), iovstack, &iov);
+        if (ret < 0)
+                return ret;
+        if (ret == 0)
+                goto no_payload_free;
+
+        ret = keyctl_instantiate_key_common(id, iov, ioc, ret, ringid);
+
+        if (iov != iovstack)
+                kfree(iov);
+        return ret;
+
+no_payload_free:
+        if (iov != iovstack)
+                kfree(iov);
+no_payload:
+        return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid);
+}
+
+/*
+ * Negatively instantiate the key with the given timeout (in seconds) and link
+ * the key into the destination keyring if one is given.
+ *
+ * The caller must have the appropriate instantiation permit set for this to
+ * work (see keyctl_assume_authority).  No other permissions are required.
+ *
+ * The key and any links to the key will be automatically garbage collected
+ * after the timeout expires.
+ *
+ * Negative keys are used to rate limit repeated request_key() calls by causing
+ * them to return -ENOKEY until the negative key expires.
+ *
+ * If successful, 0 will be returned.
  */
 long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid)
 {
+        return keyctl_reject_key(id, timeout, ENOKEY, ringid);
+}
+
+/*
+ * Negatively instantiate the key with the given timeout (in seconds) and error
+ * code and link the key into the destination keyring if one is given.
+ *
+ * The caller must have the appropriate instantiation permit set for this to
+ * work (see keyctl_assume_authority).  No other permissions are required.
+ *
+ * The key and any links to the key will be automatically garbage collected
+ * after the timeout expires.
+ *
+ * Negative keys are used to rate limit repeated request_key() calls by causing
+ * them to return the specified error code until the negative key expires.
+ *
+ * If successful, 0 will be returned.
+ */
+long keyctl_reject_key(key_serial_t id, unsigned timeout, unsigned error,
+                       key_serial_t ringid)
+{
         const struct cred *cred = current_cred();
         struct request_key_auth *rka;
         struct key *instkey, *dest_keyring;
         long ret;
 
-        kenter("%d,%u,%d", id, timeout, ringid);
+        kenter("%d,%u,%u,%d", id, timeout, error, ringid);
+
+        /* must be a valid error code and mustn't be a kernel special */
+        if (error <= 0 ||
+            error >= MAX_ERRNO ||
+            error == ERESTARTSYS ||
+            error == ERESTARTNOINTR ||
+            error == ERESTARTNOHAND ||
+            error == ERESTART_RESTARTBLOCK)
+                return -EINVAL;
 
         /* the appropriate instantiation authorisation key must have been
          * assumed before calling this */
@@ -1008,7 +1156,7 @@ long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid)
                 goto error;
 
         /* instantiate the key and link it into a keyring */
-        ret = key_negate_and_link(rka->target_key, timeout,
+        ret = key_reject_and_link(rka->target_key, timeout, error,
                                   dest_keyring, instkey);
 
         key_put(dest_keyring);
@@ -1020,13 +1168,14 @@ long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid)
 
 error:
         return ret;
+}
 
-} /* end keyctl_negate_key() */
-
-/*****************************************************************************/
 /*
- * set the default keyring in which request_key() will cache keys
- * - return the old setting
+ * Read or set the default keyring in which request_key() will cache keys and
+ * return the old setting.
+ *
+ * If a process keyring is specified then this will be created if it doesn't
+ * yet exist.  The old setting will be returned if successful.
  */
 long keyctl_set_reqkey_keyring(int reqkey_defl)
 {
@@ -1079,12 +1228,19 @@ set:
 error:
         abort_creds(new);
         return ret;
+}
 
-} /* end keyctl_set_reqkey_keyring() */
-
-/*****************************************************************************/
 /*
- * set or clear the timeout for a key
+ * Set or clear the timeout on a key.
+ *
+ * Either the key must grant the caller Setattr permission or else the caller
+ * must hold an instantiation authorisation token for the key.
+ *
+ * The timeout is either 0 to clear the timeout, or a number of seconds from
+ * the current time.  The key and any links to the key will be automatically
+ * garbage collected after the timeout expires.
+ *
+ * If successful, 0 is returned.
  */
 long keyctl_set_timeout(key_serial_t id, unsigned timeout)
 {
@@ -1136,12 +1292,24 @@ okay:
         ret = 0;
 error:
         return ret;
+}
 
-} /* end keyctl_set_timeout() */
-
-/*****************************************************************************/
 /*
- * assume the authority to instantiate the specified key
+ * Assume (or clear) the authority to instantiate the specified key.
+ *
+ * This sets the authoritative token currently in force for key instantiation.
+ * This must be done for a key to be instantiated.  It has the effect of making
+ * available all the keys from the caller of the request_key() that created a
+ * key to request_key() calls made by the caller of this function.
+ *
+ * The caller must have the instantiation key in their process keyrings with a
+ * Search permission grant available to the caller.
+ *
+ * If the ID given is 0, then the setting will be cleared and 0 returned.
+ *
+ * If the ID given has a matching an authorisation key, then that key will be
+ * set and its ID will be returned.  The authorisation key can be read to get
+ * the callout information passed to request_key().
  */
 long keyctl_assume_authority(key_serial_t id)
 {
@@ -1178,16 +1346,17 @@ long keyctl_assume_authority(key_serial_t id)
         ret = authkey->serial;
 error:
         return ret;
-
-} /* end keyctl_assume_authority() */
+}
 
 /*
- * get the security label of a key
- * - the key must grant us view permission
- * - if there's a buffer, we place up to buflen bytes of data into it
- * - unless there's an error, we return the amount of information available,
- *   irrespective of how much we may have copied (including the terminal NUL)
- * - implements keyctl(KEYCTL_GET_SECURITY)
+ * Get a key's the LSM security label.
+ *
+ * The key must grant the caller View permission for this to work.
+ *
+ * If there's a buffer, then up to buflen bytes of data will be placed into it.
+ *
+ * If successful, the amount of information available will be returned,
+ * irrespective of how much was copied (including the terminal NUL).
  */
 long keyctl_get_security(key_serial_t keyid,
                          char __user *buffer,
@@ -1242,10 +1411,16 @@ long keyctl_get_security(key_serial_t keyid,
 }
 
 /*
- * attempt to install the calling process's session keyring on the process's
- * parent process
- * - the keyring must exist and must grant us LINK permission
- * - implements keyctl(KEYCTL_SESSION_TO_PARENT)
+ * Attempt to install the calling process's session keyring on the process's
+ * parent process.
+ *
+ * The keyring must exist and must grant the caller LINK permission, and the
+ * parent process must be single-threaded and must have the same effective
+ * ownership as this process and mustn't be SUID/SGID.
+ *
+ * The keyring will be emplaced on the parent when it next resumes userspace.
+ *
+ * If successful, 0 will be returned.
  */
 long keyctl_session_to_parent(void)
 {
@@ -1348,9 +1523,8 @@ error_keyring:
 #endif /* !TIF_NOTIFY_RESUME */
 }
 
-/*****************************************************************************/
 /*
- * the key control system call
+ * The key control system call
  */
 SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3,
                 unsigned long, arg4, unsigned long, arg5)
@@ -1436,8 +1610,20 @@ SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3,
         case KEYCTL_SESSION_TO_PARENT:
                 return keyctl_session_to_parent();
 
+        case KEYCTL_REJECT:
+                return keyctl_reject_key((key_serial_t) arg2,
+                                         (unsigned) arg3,
+                                         (unsigned) arg4,
+                                         (key_serial_t) arg5);
+
+        case KEYCTL_INSTANTIATE_IOV:
+                return keyctl_instantiate_key_iov(
+                        (key_serial_t) arg2,
+                        (const struct iovec __user *) arg3,
+                        (unsigned) arg4,
+                        (key_serial_t) arg5);
+
         default:
                 return -EOPNOTSUPP;
         }
-
-} /* end sys_keyctl() */
+}
diff --git a/security/keys/keyring.c b/security/keys/keyring.c
index d37f713e73ce..a06ffab38568 100644
--- a/security/keys/keyring.c
+++ b/security/keys/keyring.c
@@ -25,14 +25,16 @@
                 (keyring)->payload.subscriptions,                       \
                 rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
 
+#define KEY_LINK_FIXQUOTA 1UL
+
 /*
- * when plumbing the depths of the key tree, this sets a hard limit set on how
- * deep we're willing to go
+ * When plumbing the depths of the key tree, this sets a hard limit
+ * set on how deep we're willing to go.
  */
 #define KEYRING_SEARCH_MAX_DEPTH 6
 
 /*
- * we keep all named keyrings in a hash to speed looking them up
+ * We keep all named keyrings in a hash to speed looking them up.
  */
 #define KEYRING_NAME_HASH_SIZE  (1 << 5)
 
@@ -50,7 +52,9 @@ static inline unsigned keyring_hash(const char *desc)
 }
 
 /*
- * the keyring type definition
+ * The keyring key type definition.  Keyrings are simply keys of this type and
+ * can be treated as ordinary keys in addition to having their own special
+ * operations.
  */
 static int keyring_instantiate(struct key *keyring,
                                const void *data, size_t datalen);
@@ -71,19 +75,17 @@ struct key_type key_type_keyring = {
         .describe       = keyring_describe,
         .read           = keyring_read,
 };
-
 EXPORT_SYMBOL(key_type_keyring);
 
 /*
- * semaphore to serialise link/link calls to prevent two link calls in parallel
- * introducing a cycle
+ * Semaphore to serialise link/link calls to prevent two link calls in parallel
+ * introducing a cycle.
  */
 static DECLARE_RWSEM(keyring_serialise_link_sem);
 
-/*****************************************************************************/
 /*
- * publish the name of a keyring so that it can be found by name (if it has
- * one)
+ * Publish the name of a keyring so that it can be found by name (if it has
+ * one).
  */
 static void keyring_publish_name(struct key *keyring)
 {
@@ -102,13 +104,12 @@ static void keyring_publish_name(struct key *keyring)
 
                 write_unlock(&keyring_name_lock);
         }
+}
 
-} /* end keyring_publish_name() */
-
-/*****************************************************************************/
 /*
- * initialise a keyring
- * - we object if we were given any data
+ * Initialise a keyring.
+ *
+ * Returns 0 on success, -EINVAL if given any data.
  */
 static int keyring_instantiate(struct key *keyring,
                                const void *data, size_t datalen)
@@ -123,23 +124,20 @@ static int keyring_instantiate(struct key *keyring,
         }
 
         return ret;
+}
 
-} /* end keyring_instantiate() */
-
-/*****************************************************************************/
 /*
- * match keyrings on their name
+ * Match keyrings on their name
  */
 static int keyring_match(const struct key *keyring, const void *description)
 {
         return keyring->description &&
                 strcmp(keyring->description, description) == 0;
+}
 
-} /* end keyring_match() */
-
-/*****************************************************************************/
 /*
- * dispose of the data dangling from the corpse of a keyring
+ * Clean up a keyring when it is destroyed.  Unpublish its name if it had one
+ * and dispose of its data.
  */
 static void keyring_destroy(struct key *keyring)
 {
@@ -164,12 +162,10 @@ static void keyring_destroy(struct key *keyring)
                         key_put(klist->keys[loop]);
                 kfree(klist);
         }
+}
 
-} /* end keyring_destroy() */
-
-/*****************************************************************************/
 /*
- * describe the keyring
+ * Describe a keyring for /proc.
  */
 static void keyring_describe(const struct key *keyring, struct seq_file *m)
 {
@@ -180,20 +176,21 @@ static void keyring_describe(const struct key *keyring, struct seq_file *m)
         else
                 seq_puts(m, "[anon]");
 
-        rcu_read_lock();
-        klist = rcu_dereference(keyring->payload.subscriptions);
-        if (klist)
-                seq_printf(m, ": %u/%u", klist->nkeys, klist->maxkeys);
-        else
-                seq_puts(m, ": empty");
-        rcu_read_unlock();
-
-} /* end keyring_describe() */
+        if (key_is_instantiated(keyring)) {
+                rcu_read_lock();
+                klist = rcu_dereference(keyring->payload.subscriptions);
+                if (klist)
+                        seq_printf(m, ": %u/%u", klist->nkeys, klist->maxkeys);
+                else
+                        seq_puts(m, ": empty");
+                rcu_read_unlock();
+        }
+}
 
-/*****************************************************************************/
 /*
- * read a list of key IDs from the keyring's contents
- * - the keyring's semaphore is read-locked
+ * Read a list of key IDs from the keyring's contents in binary form
+ *
+ * The keyring's semaphore is read-locked by the caller.
  */
 static long keyring_read(const struct key *keyring,
                          char __user *buffer, size_t buflen)
@@ -241,12 +238,10 @@ static long keyring_read(const struct key *keyring,
 
 error:
         return ret;
+}
 
-} /* end keyring_read() */
-
-/*****************************************************************************/
 /*
- * allocate a keyring and link into the destination keyring
+ * Allocate a keyring and link into the destination keyring.
  */
 struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
                           const struct cred *cred, unsigned long flags,
@@ -269,26 +264,50 @@ struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
         }
 
         return keyring;
+}
 
-} /* end keyring_alloc() */
-
-/*****************************************************************************/
-/*
- * search the supplied keyring tree for a key that matches the criterion
- * - perform a breadth-then-depth search up to the prescribed limit
- * - we only find keys on which we have search permission
- * - we use the supplied match function to see if the description (or other
- *   feature of interest) matches
- * - we rely on RCU to prevent the keyring lists from disappearing on us
- * - we return -EAGAIN if we didn't find any matching key
- * - we return -ENOKEY if we only found negative matching keys
- * - we propagate the possession attribute from the keyring ref to the key ref
+/**
+ * keyring_search_aux - Search a keyring tree for a key matching some criteria
+ * @keyring_ref: A pointer to the keyring with possession indicator.
+ * @cred: The credentials to use for permissions checks.
+ * @type: The type of key to search for.
+ * @description: Parameter for @match.
+ * @match: Function to rule on whether or not a key is the one required.
+ * @no_state_check: Don't check if a matching key is bad
+ *
+ * Search the supplied keyring tree for a key that matches the criteria given.
+ * The root keyring and any linked keyrings must grant Search permission to the
+ * caller to be searchable and keys can only be found if they too grant Search
+ * to the caller. The possession flag on the root keyring pointer controls use
+ * of the possessor bits in permissions checking of the entire tree.  In
+ * addition, the LSM gets to forbid keyring searches and key matches.
+ *
+ * The search is performed as a breadth-then-depth search up to the prescribed
+ * limit (KEYRING_SEARCH_MAX_DEPTH).
+ *
+ * Keys are matched to the type provided and are then filtered by the match
+ * function, which is given the description to use in any way it sees fit.  The
+ * match function may use any attributes of a key that it wishes to to
+ * determine the match.  Normally the match function from the key type would be
+ * used.
+ *
+ * RCU is used to prevent the keyring key lists from disappearing without the
+ * need to take lots of locks.
+ *
+ * Returns a pointer to the found key and increments the key usage count if
+ * successful; -EAGAIN if no matching keys were found, or if expired or revoked
+ * keys were found; -ENOKEY if only negative keys were found; -ENOTDIR if the
+ * specified keyring wasn't a keyring.
+ *
+ * In the case of a successful return, the possession attribute from
+ * @keyring_ref is propagated to the returned key reference.
  */
 key_ref_t keyring_search_aux(key_ref_t keyring_ref,
                              const struct cred *cred,
                              struct key_type *type,
                              const void *description,
-                             key_match_func_t match)
+                             key_match_func_t match,
+                             bool no_state_check)
 {
         struct {
                 struct keyring_list *keylist;
@@ -330,6 +349,8 @@ key_ref_t keyring_search_aux(key_ref_t keyring_ref,
         kflags = keyring->flags;
         if (keyring->type == type && match(keyring, description)) {
                 key = keyring;
+                if (no_state_check)
+                        goto found;
 
                 /* check it isn't negative and hasn't expired or been
                  * revoked */
@@ -337,7 +358,7 @@ key_ref_t keyring_search_aux(key_ref_t keyring_ref,
                         goto error_2;
                 if (key->expiry && now.tv_sec >= key->expiry)
                         goto error_2;
-                key_ref = ERR_PTR(-ENOKEY);
+                key_ref = ERR_PTR(key->type_data.reject_error);
                 if (kflags & (1 << KEY_FLAG_NEGATIVE))
                         goto error_2;
                 goto found;
@@ -369,11 +390,13 @@ descend:
                         continue;
 
                 /* skip revoked keys and expired keys */
-                if (kflags & (1 << KEY_FLAG_REVOKED))
-                        continue;
+                if (!no_state_check) {
+                        if (kflags & (1 << KEY_FLAG_REVOKED))
+                                continue;
 
-                if (key->expiry && now.tv_sec >= key->expiry)
-                        continue;
+                        if (key->expiry && now.tv_sec >= key->expiry)
+                                continue;
+                }
 
                 /* keys that don't match */
                 if (!match(key, description))
@@ -384,9 +407,12 @@ descend:
                                         cred, KEY_SEARCH) < 0)
                         continue;
 
+                if (no_state_check)
+                        goto found;
+
                 /* we set a different error code if we pass a negative key */
                 if (kflags & (1 << KEY_FLAG_NEGATIVE)) {
-                        err = -ENOKEY;
+                        err = key->type_data.reject_error;
                         continue;
                 }
 
@@ -444,17 +470,16 @@ error_2:
         rcu_read_unlock();
 error:
         return key_ref;
+}
 
-} /* end keyring_search_aux() */
-
-/*****************************************************************************/
-/*
- * search the supplied keyring tree for a key that matches the criterion
- * - perform a breadth-then-depth search up to the prescribed limit
- * - we only find keys on which we have search permission
- * - we readlock the keyrings as we search down the tree
- * - we return -EAGAIN if we didn't find any matching key
- * - we return -ENOKEY if we only found negative matching keys
+/**
+ * keyring_search - Search the supplied keyring tree for a matching key
+ * @keyring: The root of the keyring tree to be searched.
+ * @type: The type of keyring we want to find.
+ * @description: The name of the keyring we want to find.
+ *
+ * As keyring_search_aux() above, but using the current task's credentials and
+ * type's default matching function.
  */
 key_ref_t keyring_search(key_ref_t keyring,
                          struct key_type *type,
@@ -464,17 +489,24 @@ key_ref_t keyring_search(key_ref_t keyring,
                 return ERR_PTR(-ENOKEY);
 
         return keyring_search_aux(keyring, current->cred,
-                                  type, description, type->match);
-
-} /* end keyring_search() */
-
+                                  type, description, type->match, false);
+}
 EXPORT_SYMBOL(keyring_search);
 
-/*****************************************************************************/
 /*
- * search the given keyring only (no recursion)
- * - keyring must be locked by caller
- * - caller must guarantee that the keyring is a keyring
+ * Search the given keyring only (no recursion).
+ *
+ * The caller must guarantee that the keyring is a keyring and that the
+ * permission is granted to search the keyring as no check is made here.
+ *
+ * RCU is used to make it unnecessary to lock the keyring key list here.
+ *
+ * Returns a pointer to the found key with usage count incremented if
+ * successful and returns -ENOKEY if not found.  Revoked keys and keys not
+ * providing the requested permission are skipped over.
+ *
+ * If successful, the possession indicator is propagated from the keyring ref
+ * to the returned key reference.
  */
 key_ref_t __keyring_search_one(key_ref_t keyring_ref,
                                const struct key_type *ktype,
@@ -514,14 +546,18 @@ found:
         atomic_inc(&key->usage);
         rcu_read_unlock();
         return make_key_ref(key, possessed);
+}
 
-} /* end __keyring_search_one() */
-
-/*****************************************************************************/
 /*
- * find a keyring with the specified name
- * - all named keyrings are searched
- * - normally only finds keyrings with search permission for the current process
+ * Find a keyring with the specified name.
+ *
+ * All named keyrings in the current user namespace are searched, provided they
+ * grant Search permission directly to the caller (unless this check is
+ * skipped).  Keyrings whose usage points have reached zero or who have been
+ * revoked are skipped.
+ *
+ * Returns a pointer to the keyring with the keyring's refcount having being
+ * incremented on success.  -ENOKEY is returned if a key could not be found.
  */
 struct key *find_keyring_by_name(const char *name, bool skip_perm_check)
 {
@@ -569,15 +605,14 @@ struct key *find_keyring_by_name(const char *name, bool skip_perm_check)
 out:
         read_unlock(&keyring_name_lock);
         return keyring;
+}
 
-} /* end find_keyring_by_name() */
-
-/*****************************************************************************/
 /*
- * see if a cycle will will be created by inserting acyclic tree B in acyclic
- * tree A at the topmost level (ie: as a direct child of A)
- * - since we are adding B to A at the top level, checking for cycles should
- *   just be a matter of seeing if node A is somewhere in tree B
+ * See if a cycle will will be created by inserting acyclic tree B in acyclic
+ * tree A at the topmost level (ie: as a direct child of A).
+ *
+ * Since we are adding B to A at the top level, checking for cycles should just
+ * be a matter of seeing if node A is somewhere in tree B.
  */
 static int keyring_detect_cycle(struct key *A, struct key *B)
 {
@@ -657,11 +692,10 @@ too_deep:
 cycle_detected:
         ret = -EDEADLK;
         goto error;
-
-} /* end keyring_detect_cycle() */
+}
 
 /*
- * dispose of a keyring list after the RCU grace period, freeing the unlinked
+ * Dispose of a keyring list after the RCU grace period, freeing the unlinked
  * key
  */
 static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
@@ -675,14 +709,14 @@ static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
 }
 
 /*
- * preallocate memory so that a key can be linked into to a keyring
+ * Preallocate memory so that a key can be linked into to a keyring.
  */
 int __key_link_begin(struct key *keyring, const struct key_type *type,
-                     const char *description,
-                     struct keyring_list **_prealloc)
+                     const char *description, unsigned long *_prealloc)
         __acquires(&keyring->sem)
 {
         struct keyring_list *klist, *nklist;
+        unsigned long prealloc;
         unsigned max;
         size_t size;
         int loop, ret;
@@ -725,6 +759,7 @@ int __key_link_begin(struct key *keyring, const struct key_type *type,
 
                                 /* note replacement slot */
                                 klist->delkey = nklist->delkey = loop;
+                                prealloc = (unsigned long)nklist;
                                 goto done;
                         }
                 }
@@ -739,6 +774,7 @@ int __key_link_begin(struct key *keyring, const struct key_type *type,
         if (klist && klist->nkeys < klist->maxkeys) {
                 /* there's sufficient slack space to append directly */
                 nklist = NULL;
+                prealloc = KEY_LINK_FIXQUOTA;
         } else {
                 /* grow the key list */
                 max = 4;
@@ -773,8 +809,9 @@ int __key_link_begin(struct key *keyring, const struct key_type *type,
                 nklist->keys[nklist->delkey] = NULL;
         }
 
+        prealloc = (unsigned long)nklist | KEY_LINK_FIXQUOTA;
 done:
-        *_prealloc = nklist;
+        *_prealloc = prealloc;
         kleave(" = 0");
         return 0;
 
@@ -792,10 +829,10 @@ error_krsem:
 }
 
 /*
- * check already instantiated keys aren't going to be a problem
- * - the caller must have called __key_link_begin()
- * - don't need to call this for keys that were created since __key_link_begin()
- *   was called
+ * Check already instantiated keys aren't going to be a problem.
+ *
+ * The caller must have called __key_link_begin(). Don't need to call this for
+ * keys that were created since __key_link_begin() was called.
  */
 int __key_link_check_live_key(struct key *keyring, struct key *key)
 {
@@ -807,17 +844,20 @@ int __key_link_check_live_key(struct key *keyring, struct key *key)
 }
 
 /*
- * link a key into to a keyring
- * - must be called with __key_link_begin() having being called
- * - discard already extant link to matching key if there is one
+ * Link a key into to a keyring.
+ *
+ * Must be called with __key_link_begin() having being called.  Discards any
+ * already extant link to matching key if there is one, so that each keyring
+ * holds at most one link to any given key of a particular type+description
+ * combination.
  */
 void __key_link(struct key *keyring, struct key *key,
-                struct keyring_list **_prealloc)
+                unsigned long *_prealloc)
 {
         struct keyring_list *klist, *nklist;
 
-        nklist = *_prealloc;
-        *_prealloc = NULL;
+        nklist = (struct keyring_list *)(*_prealloc & ~KEY_LINK_FIXQUOTA);
+        *_prealloc = 0;
 
         kenter("%d,%d,%p", keyring->serial, key->serial, nklist);
 
@@ -852,34 +892,54 @@ void __key_link(struct key *keyring, struct key *key,
 }
 
 /*
- * finish linking a key into to a keyring
- * - must be called with __key_link_begin() having being called
+ * Finish linking a key into to a keyring.
+ *
+ * Must be called with __key_link_begin() having being called.
  */
 void __key_link_end(struct key *keyring, struct key_type *type,
-                    struct keyring_list *prealloc)
+                    unsigned long prealloc)
         __releases(&keyring->sem)
 {
         BUG_ON(type == NULL);
         BUG_ON(type->name == NULL);
-        kenter("%d,%s,%p", keyring->serial, type->name, prealloc);
+        kenter("%d,%s,%lx", keyring->serial, type->name, prealloc);
 
         if (type == &key_type_keyring)
                 up_write(&keyring_serialise_link_sem);
 
         if (prealloc) {
-                kfree(prealloc);
-                key_payload_reserve(keyring,
-                                    keyring->datalen - KEYQUOTA_LINK_BYTES);
+                if (prealloc & KEY_LINK_FIXQUOTA)
+                        key_payload_reserve(keyring,
+                                            keyring->datalen -
+                                            KEYQUOTA_LINK_BYTES);
+                kfree((struct keyring_list *)(prealloc & ~KEY_LINK_FIXQUOTA));
         }
         up_write(&keyring->sem);
 }
 
-/*
- * link a key to a keyring
+/**
+ * key_link - Link a key to a keyring
+ * @keyring: The keyring to make the link in.
+ * @key: The key to link to.
+ *
+ * Make a link in a keyring to a key, such that the keyring holds a reference
+ * on that key and the key can potentially be found by searching that keyring.
+ *
+ * This function will write-lock the keyring's semaphore and will consume some
+ * of the user's key data quota to hold the link.
+ *
+ * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring,
+ * -EKEYREVOKED if the keyring has been revoked, -ENFILE if the keyring is
+ * full, -EDQUOT if there is insufficient key data quota remaining to add
+ * another link or -ENOMEM if there's insufficient memory.
+ *
+ * It is assumed that the caller has checked that it is permitted for a link to
+ * be made (the keyring should have Write permission and the key Link
+ * permission).
  */
 int key_link(struct key *keyring, struct key *key)
 {
-        struct keyring_list *prealloc;
+        unsigned long prealloc;
         int ret;
 
         key_check(keyring);
@@ -895,12 +955,24 @@ int key_link(struct key *keyring, struct key *key)
 
         return ret;
 }
-
 EXPORT_SYMBOL(key_link);
 
-/*****************************************************************************/
-/*
- * unlink the first link to a key from a keyring
+/**
+ * key_unlink - Unlink the first link to a key from a keyring.
+ * @keyring: The keyring to remove the link from.
+ * @key: The key the link is to.
+ *
+ * Remove a link from a keyring to a key.
+ *
+ * This function will write-lock the keyring's semaphore.
+ *
+ * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring, -ENOENT if
+ * the key isn't linked to by the keyring or -ENOMEM if there's insufficient
+ * memory.
+ *
+ * It is assumed that the caller has checked that it is permitted for a link to
+ * be removed (the keyring should have Write permission; no permissions are
+ * required on the key).
  */
 int key_unlink(struct key *keyring, struct key *key)
 {
@@ -968,15 +1040,12 @@ nomem:
         ret = -ENOMEM;
         up_write(&keyring->sem);
         goto error;
-
-} /* end key_unlink() */
-
+}
 EXPORT_SYMBOL(key_unlink);
 
-/*****************************************************************************/
 /*
- * dispose of a keyring list after the RCU grace period, releasing the keys it
- * links to
+ * Dispose of a keyring list after the RCU grace period, releasing the keys it
+ * links to.
  */
 static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
 {
@@ -989,13 +1058,15 @@ static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
                 key_put(klist->keys[loop]);
 
         kfree(klist);
+}
 
-} /* end keyring_clear_rcu_disposal() */
-
-/*****************************************************************************/
-/*
- * clear the specified process keyring
- * - implements keyctl(KEYCTL_CLEAR)
+/**
+ * keyring_clear - Clear a keyring
+ * @keyring: The keyring to clear.
+ *
+ * Clear the contents of the specified keyring.
+ *
+ * Returns 0 if successful or -ENOTDIR if the keyring isn't a keyring.
  */
 int keyring_clear(struct key *keyring)
 {
@@ -1027,15 +1098,13 @@ int keyring_clear(struct key *keyring)
         }
 
         return ret;
-
-} /* end keyring_clear() */
-
+}
 EXPORT_SYMBOL(keyring_clear);
 
-/*****************************************************************************/
 /*
- * dispose of the links from a revoked keyring
- * - called with the key sem write-locked
+ * Dispose of the links from a revoked keyring.
+ *
+ * This is called with the key sem write-locked.
  */
 static void keyring_revoke(struct key *keyring)
 {
@@ -1050,11 +1119,10 @@ static void keyring_revoke(struct key *keyring)
                 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
                 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
         }
-
-} /* end keyring_revoke() */
+}
 
 /*
- * Determine whether a key is dead
+ * Determine whether a key is dead.
  */
 static bool key_is_dead(struct key *key, time_t limit)
 {
@@ -1063,7 +1131,12 @@ static bool key_is_dead(struct key *key, time_t limit)
 }
 
 /*
- * Collect garbage from the contents of a keyring
+ * Collect garbage from the contents of a keyring, replacing the old list with
+ * a new one with the pointers all shuffled down.
+ *
+ * Dead keys are classed as oned that are flagged as being dead or are revoked,
+ * expired or negative keys that were revoked or expired before the specified
+ * limit.
  */
 void keyring_gc(struct key *keyring, time_t limit)
 {
diff --git a/security/keys/permission.c b/security/keys/permission.c
index 28645502cd0d..c35b5229e3cd 100644
--- a/security/keys/permission.c
+++ b/security/keys/permission.c
@@ -1,4 +1,4 @@
-/* permission.c: key permission determination
+/* Key permission checking
  *
  * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -13,18 +13,19 @@
 #include <linux/security.h>
 #include "internal.h"
 
-/*****************************************************************************/
 /**
  * key_task_permission - Check a key can be used
- * @key_ref: The key to check
- * @cred: The credentials to use
- * @perm: The permissions to check for
+ * @key_ref: The key to check.
+ * @cred: The credentials to use.
+ * @perm: The permissions to check for.
  *
  * Check to see whether permission is granted to use a key in the desired way,
  * but permit the security modules to override.
  *
- * The caller must hold either a ref on cred or must hold the RCU readlock or a
- * spinlock.
+ * The caller must hold either a ref on cred or must hold the RCU readlock.
+ *
+ * Returns 0 if successful, -EACCES if access is denied based on the
+ * permissions bits or the LSM check.
  */
 int key_task_permission(const key_ref_t key_ref, const struct cred *cred,
                         key_perm_t perm)
@@ -79,14 +80,16 @@ use_these_perms:
 
         /* let LSM be the final arbiter */
         return security_key_permission(key_ref, cred, perm);
-
-} /* end key_task_permission() */
-
+}
 EXPORT_SYMBOL(key_task_permission);
 
-/*****************************************************************************/
-/*
- * validate a key
+/**
+ * key_validate - Validate a key.
+ * @key: The key to be validated.
+ *
+ * Check that a key is valid, returning 0 if the key is okay, -EKEYREVOKED if
+ * the key's type has been removed or if the key has been revoked or
+ * -EKEYEXPIRED if the key has expired.
  */
 int key_validate(struct key *key)
 {
@@ -111,7 +114,5 @@ int key_validate(struct key *key)
 
 error:
         return ret;
-
-} /* end key_validate() */
-
+}
 EXPORT_SYMBOL(key_validate);
diff --git a/security/keys/proc.c b/security/keys/proc.c
index 70373966816e..49bbc97943ad 100644
--- a/security/keys/proc.c
+++ b/security/keys/proc.c
@@ -1,4 +1,4 @@
-/* proc.c: proc files for key database enumeration
+/* procfs files for key database enumeration
  *
  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -60,9 +60,8 @@ static const struct file_operations proc_key_users_fops = {
         .release        = seq_release,
 };
 
-/*****************************************************************************/
 /*
- * declare the /proc files
+ * Declare the /proc files.
  */
 static int __init key_proc_init(void)
 {
@@ -79,14 +78,13 @@ static int __init key_proc_init(void)
                 panic("Cannot create /proc/key-users\n");
 
         return 0;
-
-} /* end key_proc_init() */
+}
 
 __initcall(key_proc_init);
 
-/*****************************************************************************/
 /*
- * implement "/proc/keys" to provides a list of the keys on the system
+ * Implement "/proc/keys" to provide a list of the keys on the system that
+ * grant View permission to the caller.
  */
 #ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
 
@@ -201,7 +199,7 @@ static int proc_keys_show(struct seq_file *m, void *v)
         if (key->perm & KEY_POS_VIEW) {
                 skey_ref = search_my_process_keyrings(key->type, key,
                                                       lookup_user_key_possessed,
-                                                      cred);
+                                                      true, cred);
                 if (!IS_ERR(skey_ref)) {
                         key_ref_put(skey_ref);
                         key_ref = make_key_ref(key, 1);
@@ -293,9 +291,9 @@ static struct rb_node *key_user_first(struct rb_root *r)
         return __key_user_next(n);
 }
 
-/*****************************************************************************/
 /*
- * implement "/proc/key-users" to provides a list of the key users
+ * Implement "/proc/key-users" to provides a list of the key users and their
+ * quotas.
  */
 static int proc_key_users_open(struct inode *inode, struct file *file)
 {
@@ -351,5 +349,4 @@ static int proc_key_users_show(struct seq_file *m, void *v)
                    maxbytes);
 
         return 0;
-
 }
diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c
index f8e7251ae2c8..a3063eb3dc23 100644
--- a/security/keys/process_keys.c
+++ b/security/keys/process_keys.c
@@ -1,4 +1,4 @@
-/* Management of a process's keyrings
+/* Manage a process's keyrings
  *
  * Copyright (C) 2004-2005, 2008 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -21,13 +21,13 @@
 #include <asm/uaccess.h>
 #include "internal.h"
 
-/* session keyring create vs join semaphore */
+/* Session keyring create vs join semaphore */
 static DEFINE_MUTEX(key_session_mutex);
 
-/* user keyring creation semaphore */
+/* User keyring creation semaphore */
 static DEFINE_MUTEX(key_user_keyring_mutex);
 
-/* the root user's tracking struct */
+/* The root user's tracking struct */
 struct key_user root_key_user = {
         .usage          = ATOMIC_INIT(3),
         .cons_lock      = __MUTEX_INITIALIZER(root_key_user.cons_lock),
@@ -38,9 +38,8 @@ struct key_user root_key_user = {
         .user_ns        = &init_user_ns,
 };
 
-/*****************************************************************************/
 /*
- * install user and user session keyrings for a particular UID
+ * Install the user and user session keyrings for the current process's UID.
  */
 int install_user_keyrings(void)
 {
@@ -122,7 +121,8 @@ error:
 }
 
 /*
- * install a fresh thread keyring directly to new credentials
+ * Install a fresh thread keyring directly to new credentials.  This keyring is
+ * allowed to overrun the quota.
  */
 int install_thread_keyring_to_cred(struct cred *new)
 {
@@ -138,7 +138,7 @@ int install_thread_keyring_to_cred(struct cred *new)
 }
 
 /*
- * install a fresh thread keyring, discarding the old one
+ * Install a fresh thread keyring, discarding the old one.
  */
 static int install_thread_keyring(void)
 {
@@ -161,9 +161,10 @@ static int install_thread_keyring(void)
 }
 
 /*
- * install a process keyring directly to a credentials struct
- * - returns -EEXIST if there was already a process keyring, 0 if one installed,
- *   and other -ve on any other error
+ * Install a process keyring directly to a credentials struct.
+ *
+ * Returns -EEXIST if there was already a process keyring, 0 if one installed,
+ * and other value on any other error
  */
 int install_process_keyring_to_cred(struct cred *new)
 {
@@ -192,8 +193,11 @@ int install_process_keyring_to_cred(struct cred *new)
 }
 
 /*
- * make sure a process keyring is installed
- * - we
+ * Make sure a process keyring is installed for the current process.  The
+ * existing process keyring is not replaced.
+ *
+ * Returns 0 if there is a process keyring by the end of this function, some
+ * error otherwise.
  */
 static int install_process_keyring(void)
 {
@@ -207,14 +211,14 @@ static int install_process_keyring(void)
         ret = install_process_keyring_to_cred(new);
         if (ret < 0) {
                 abort_creds(new);
-                return ret != -EEXIST ?: 0;
+                return ret != -EEXIST ? ret : 0;
         }
 
         return commit_creds(new);
 }
 
 /*
- * install a session keyring directly to a credentials struct
+ * Install a session keyring directly to a credentials struct.
  */
 int install_session_keyring_to_cred(struct cred *cred, struct key *keyring)
 {
@@ -254,8 +258,8 @@ int install_session_keyring_to_cred(struct cred *cred, struct key *keyring)
 }
 
 /*
- * install a session keyring, discarding the old one
- * - if a keyring is not supplied, an empty one is invented
+ * Install a session keyring, discarding the old one.  If a keyring is not
+ * supplied, an empty one is invented.
  */
 static int install_session_keyring(struct key *keyring)
 {
@@ -275,9 +279,8 @@ static int install_session_keyring(struct key *keyring)
         return commit_creds(new);
 }
 
-/*****************************************************************************/
 /*
- * the filesystem user ID changed
+ * Handle the fsuid changing.
  */
 void key_fsuid_changed(struct task_struct *tsk)
 {
@@ -288,12 +291,10 @@ void key_fsuid_changed(struct task_struct *tsk)
                 tsk->cred->thread_keyring->uid = tsk->cred->fsuid;
                 up_write(&tsk->cred->thread_keyring->sem);
         }
+}
 
-} /* end key_fsuid_changed() */
-
-/*****************************************************************************/
 /*
- * the filesystem group ID changed
+ * Handle the fsgid changing.
  */
 void key_fsgid_changed(struct task_struct *tsk)
 {
@@ -304,20 +305,33 @@ void key_fsgid_changed(struct task_struct *tsk)
                 tsk->cred->thread_keyring->gid = tsk->cred->fsgid;
                 up_write(&tsk->cred->thread_keyring->sem);
         }
+}
 
-} /* end key_fsgid_changed() */
-
-/*****************************************************************************/
 /*
- * search only my process keyrings for the first matching key
- * - we use the supplied match function to see if the description (or other
- *   feature of interest) matches
- * - we return -EAGAIN if we didn't find any matching key
- * - we return -ENOKEY if we found only negative matching keys
+ * Search the process keyrings attached to the supplied cred for the first
+ * matching key.
+ *
+ * The search criteria are the type and the match function.  The description is
+ * given to the match function as a parameter, but doesn't otherwise influence
+ * the search.  Typically the match function will compare the description
+ * parameter to the key's description.
+ *
+ * This can only search keyrings that grant Search permission to the supplied
+ * credentials.  Keyrings linked to searched keyrings will also be searched if
+ * they grant Search permission too.  Keys can only be found if they grant
+ * Search permission to the credentials.
+ *
+ * Returns a pointer to the key with the key usage count incremented if
+ * successful, -EAGAIN if we didn't find any matching key or -ENOKEY if we only
+ * matched negative keys.
+ *
+ * In the case of a successful return, the possession attribute is set on the
+ * returned key reference.
  */
 key_ref_t search_my_process_keyrings(struct key_type *type,
                                      const void *description,
                                      key_match_func_t match,
+                                     bool no_state_check,
                                      const struct cred *cred)
 {
         key_ref_t key_ref, ret, err;
@@ -337,7 +351,7 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
         if (cred->thread_keyring) {
                 key_ref = keyring_search_aux(
                         make_key_ref(cred->thread_keyring, 1),
-                        cred, type, description, match);
+                        cred, type, description, match, no_state_check);
                 if (!IS_ERR(key_ref))
                         goto found;
 
@@ -358,7 +372,7 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
         if (cred->tgcred->process_keyring) {
                 key_ref = keyring_search_aux(
                         make_key_ref(cred->tgcred->process_keyring, 1),
-                        cred, type, description, match);
+                        cred, type, description, match, no_state_check);
                 if (!IS_ERR(key_ref))
                         goto found;
 
@@ -382,7 +396,7 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
                         make_key_ref(rcu_dereference(
                                              cred->tgcred->session_keyring),
                                      1),
-                        cred, type, description, match);
+                        cred, type, description, match, no_state_check);
                 rcu_read_unlock();
 
                 if (!IS_ERR(key_ref))
@@ -404,7 +418,7 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
         else if (cred->user->session_keyring) {
                 key_ref = keyring_search_aux(
                         make_key_ref(cred->user->session_keyring, 1),
-                        cred, type, description, match);
+                        cred, type, description, match, no_state_check);
                 if (!IS_ERR(key_ref))
                         goto found;
 
@@ -428,13 +442,13 @@ found:
         return key_ref;
 }
 
-/*****************************************************************************/
 /*
- * search the process keyrings for the first matching key
- * - we use the supplied match function to see if the description (or other
- *   feature of interest) matches
- * - we return -EAGAIN if we didn't find any matching key
- * - we return -ENOKEY if we found only negative matching keys
+ * Search the process keyrings attached to the supplied cred for the first
+ * matching key in the manner of search_my_process_keyrings(), but also search
+ * the keys attached to the assumed authorisation key using its credentials if
+ * one is available.
+ *
+ * Return same as search_my_process_keyrings().
  */
 key_ref_t search_process_keyrings(struct key_type *type,
                                   const void *description,
@@ -446,7 +460,8 @@ key_ref_t search_process_keyrings(struct key_type *type,
 
         might_sleep();
 
-        key_ref = search_my_process_keyrings(type, description, match, cred);
+        key_ref = search_my_process_keyrings(type, description, match,
+                                             false, cred);
         if (!IS_ERR(key_ref))
                 goto found;
         err = key_ref;
@@ -489,24 +504,33 @@ key_ref_t search_process_keyrings(struct key_type *type,
 
 found:
         return key_ref;
+}
 
-} /* end search_process_keyrings() */
-
-/*****************************************************************************/
 /*
- * see if the key we're looking at is the target key
+ * See if the key we're looking at is the target key.
  */
 int lookup_user_key_possessed(const struct key *key, const void *target)
 {
         return key == target;
+}
 
-} /* end lookup_user_key_possessed() */
-
-/*****************************************************************************/
 /*
- * lookup a key given a key ID from userspace with a given permissions mask
- * - don't create special keyrings unless so requested
- * - partially constructed keys aren't found unless requested
+ * Look up a key ID given us by userspace with a given permissions mask to get
+ * the key it refers to.
+ *
+ * Flags can be passed to request that special keyrings be created if referred
+ * to directly, to permit partially constructed keys to be found and to skip
+ * validity and permission checks on the found key.
+ *
+ * Returns a pointer to the key with an incremented usage count if successful;
+ * -EINVAL if the key ID is invalid; -ENOKEY if the key ID does not correspond
+ * to a key or the best found key was a negative key; -EKEYREVOKED or
+ * -EKEYEXPIRED if the best found key was revoked or expired; -EACCES if the
+ * found key doesn't grant the requested permit or the LSM denied access to it;
+ * or -ENOMEM if a special keyring couldn't be created.
+ *
+ * In the case of a successful return, the possession attribute is set on the
+ * returned key reference.
  */
 key_ref_t lookup_user_key(key_serial_t id, unsigned long lflags,
                           key_perm_t perm)
@@ -711,15 +735,18 @@ invalid_key:
 reget_creds:
         put_cred(cred);
         goto try_again;
+}
 
-} /* end lookup_user_key() */
-
-/*****************************************************************************/
 /*
- * join the named keyring as the session keyring if possible, or attempt to
- * create a new one of that name if not
- * - if the name is NULL, an empty anonymous keyring is installed instead
- * - named session keyring joining is done with a semaphore held
+ * Join the named keyring as the session keyring if possible else attempt to
+ * create a new one of that name and join that.
+ *
+ * If the name is NULL, an empty anonymous keyring will be installed as the
+ * session keyring.
+ *
+ * Named session keyrings are joined with a semaphore held to prevent the
+ * keyrings from going away whilst the attempt is made to going them and also
+ * to prevent a race in creating compatible session keyrings.
  */
 long join_session_keyring(const char *name)
 {
@@ -791,8 +818,8 @@ error:
 }
 
 /*
- * Replace a process's session keyring when that process resumes userspace on
- * behalf of one of its children
+ * Replace a process's session keyring on behalf of one of its children when
+ * the target  process is about to resume userspace execution.
  */
 void key_replace_session_keyring(void)
 {
@@ -820,6 +847,7 @@ void key_replace_session_keyring(void)
         new-> sgid      = old-> sgid;
         new->fsgid      = old->fsgid;
         new->user       = get_uid(old->user);
+        new->user_ns    = new->user->user_ns;
         new->group_info = get_group_info(old->group_info);
 
         new->securebits = old->securebits;
diff --git a/security/keys/request_key.c b/security/keys/request_key.c
index 0088dd8bf68a..82465328c39b 100644
--- a/security/keys/request_key.c
+++ b/security/keys/request_key.c
@@ -8,7 +8,7 @@
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  *
- * See Documentation/keys-request-key.txt
+ * See Documentation/security/keys-request-key.txt
  */
 
 #include <linux/module.h>
@@ -39,8 +39,14 @@ static int key_wait_bit_intr(void *flags)
         return signal_pending(current) ? -ERESTARTSYS : 0;
 }
 
-/*
- * call to complete the construction of a key
+/**
+ * complete_request_key - Complete the construction of a key.
+ * @cons: The key construction record.
+ * @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)
 {
@@ -58,23 +64,32 @@ void complete_request_key(struct key_construction *cons, int error)
 }
 EXPORT_SYMBOL(complete_request_key);
 
-static int umh_keys_init(struct subprocess_info *info)
+/*
+ * Initialise a usermode helper that is going to have a specific session
+ * keyring.
+ *
+ * This is called in context of freshly forked kthread before kernel_execve(),
+ * so we can simply install the desired session_keyring at this point.
+ */
+static int umh_keys_init(struct subprocess_info *info, struct cred *cred)
 {
-        struct cred *cred = (struct cred*)current_cred();
         struct key *keyring = info->data;
-        /*
-         * This is called in context of freshly forked kthread before
-         * kernel_execve(), we can just change our ->session_keyring.
-         */
+
         return install_session_keyring_to_cred(cred, keyring);
 }
 
+/*
+ * Clean up a usermode helper with session keyring.
+ */
 static void umh_keys_cleanup(struct subprocess_info *info)
 {
         struct key *keyring = info->data;
         key_put(keyring);
 }
 
+/*
+ * Call a usermode helper with a specific session keyring.
+ */
 static int call_usermodehelper_keys(char *path, char **argv, char **envp,
                          struct key *session_keyring, enum umh_wait wait)
 {
@@ -91,7 +106,7 @@ static int call_usermodehelper_keys(char *path, char **argv, char **envp,
 }
 
 /*
- * request userspace finish the construction of a key
+ * 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,
@@ -198,8 +213,9 @@ error_alloc:
 }
 
 /*
- * call out to userspace for key construction
- * - we ignore program failure and go on key status instead
+ * Call out to userspace for key construction.
+ *
+ * Program failure is ignored in favour of key status.
  */
 static int construct_key(struct key *key, const void *callout_info,
                          size_t callout_len, void *aux,
@@ -246,9 +262,10 @@ static int construct_key(struct key *key, const void *callout_info,
 }
 
 /*
- * get the appropriate destination keyring for the request
- * - we return whatever keyring we select with an extra reference upon it which
- *   the caller must release
+ * Get the appropriate destination keyring for the request.
+ *
+ * The keyring selected is returned with an extra reference upon it which the
+ * caller must release.
  */
 static void construct_get_dest_keyring(struct key **_dest_keyring)
 {
@@ -321,9 +338,11 @@ static void construct_get_dest_keyring(struct key **_dest_keyring)
 }
 
 /*
- * allocate a new key in under-construction state and attempt to link it in to
- * the requested place
- * - may return a key that's already under construction instead
+ * Allocate a new key in under-construction state and attempt to link it in to
+ * the requested keyring.
+ *
+ * May return a key that's already under construction instead if there was a
+ * race between two thread calling request_key().
  */
 static int construct_alloc_key(struct key_type *type,
                                const char *description,
@@ -332,8 +351,8 @@ static int construct_alloc_key(struct key_type *type,
                                struct key_user *user,
                                struct key **_key)
 {
-        struct keyring_list *prealloc;
         const struct cred *cred = current_cred();
+        unsigned long prealloc;
         struct key *key;
         key_ref_t key_ref;
         int ret;
@@ -403,7 +422,6 @@ link_check_failed:
         return ret;
 
 link_prealloc_failed:
-        up_write(&dest_keyring->sem);
         mutex_unlock(&user->cons_lock);
         kleave(" = %d [prelink]", ret);
         return ret;
@@ -415,7 +433,7 @@ alloc_failed:
 }
 
 /*
- * commence key construction
+ * Commence key construction.
  */
 static struct key *construct_key_and_link(struct key_type *type,
                                           const char *description,
@@ -451,7 +469,7 @@ static struct key *construct_key_and_link(struct key_type *type,
         } else if (ret == -EINPROGRESS) {
                 ret = 0;
         } else {
-                key = ERR_PTR(ret);
+                goto couldnt_alloc_key;
         }
 
         key_put(dest_keyring);
@@ -461,17 +479,38 @@ static struct key *construct_key_and_link(struct key_type *type,
 construction_failed:
         key_negate_and_link(key, key_negative_timeout, NULL, NULL);
         key_put(key);
+couldnt_alloc_key:
         key_put(dest_keyring);
         kleave(" = %d", ret);
         return ERR_PTR(ret);
 }
 
-/*
- * request a key
- * - search the process's keyrings
- * - check the list of keys being created or updated
- * - call out to userspace for a key if supplementary info was provided
- * - cache the key in an appropriate keyring
+/**
+ * request_key_and_link - Request a key and cache it in a keyring.
+ * @type: The type of key we want.
+ * @description: The searchable description of the key.
+ * @callout_info: The data to pass to the instantiation upcall (or NULL).
+ * @callout_len: The length of callout_info.
+ * @aux: Auxiliary data for the upcall.
+ * @dest_keyring: Where to cache the key.
+ * @flags: Flags to key_alloc().
+ *
+ * A key matching the specified criteria is searched for in the process's
+ * keyrings and returned with its usage count incremented if found.  Otherwise,
+ * if callout_info is not NULL, a key will be allocated and some service
+ * (probably in userspace) will be asked to instantiate it.
+ *
+ * If successfully found or created, the key will be linked to the destination
+ * keyring if one is provided.
+ *
+ * Returns a pointer to the key if successful; -EACCES, -ENOKEY, -EKEYREVOKED
+ * or -EKEYEXPIRED if an inaccessible, negative, revoked or expired key was
+ * found; -ENOKEY if no key was found and no @callout_info was given; -EDQUOT
+ * if insufficient key quota was available to create a new key; or -ENOMEM if
+ * insufficient memory was available.
+ *
+ * If the returned key was created, then it may still be under construction,
+ * and wait_for_key_construction() should be used to wait for that to complete.
  */
 struct key *request_key_and_link(struct key_type *type,
                                  const char *description,
@@ -491,8 +530,7 @@ struct key *request_key_and_link(struct key_type *type,
                dest_keyring, flags);
 
         /* search all the process keyrings for a key */
-        key_ref = search_process_keyrings(type, description, type->match,
-                                          cred);
+        key_ref = search_process_keyrings(type, description, type->match, cred);
 
         if (!IS_ERR(key_ref)) {
                 key = key_ref_to_ptr(key_ref);
@@ -525,8 +563,16 @@ error:
         return key;
 }
 
-/*
- * wait for construction of a key to complete
+/**
+ * wait_for_key_construction - Wait for construction of a key to complete
+ * @key: The key being waited for.
+ * @intr: Whether to wait interruptibly.
+ *
+ * Wait for a key to finish being constructed.
+ *
+ * Returns 0 if successful; -ERESTARTSYS if the wait was interrupted; -ENOKEY
+ * if the key was negated; or -EKEYREVOKED or -EKEYEXPIRED if the key was
+ * revoked or expired.
  */
 int wait_for_key_construction(struct key *key, bool intr)
 {
@@ -538,17 +584,24 @@ int wait_for_key_construction(struct key *key, bool intr)
         if (ret < 0)
                 return ret;
         if (test_bit(KEY_FLAG_NEGATIVE, &key->flags))
-                return -ENOKEY;
+                return key->type_data.reject_error;
         return key_validate(key);
 }
 EXPORT_SYMBOL(wait_for_key_construction);
 
-/*
- * request a key
- * - search the process's keyrings
- * - check the list of keys being created or updated
- * - call out to userspace for a key if supplementary info was provided
- * - waits uninterruptible for creation to complete
+/**
+ * request_key - Request a key and wait for construction
+ * @type: Type of key.
+ * @description: The searchable description of the key.
+ * @callout_info: The data to pass to the instantiation upcall (or NULL).
+ *
+ * As for request_key_and_link() except that it does not add the returned key
+ * to a keyring if found, new keys are always allocated in the user's quota,
+ * the callout_info must be a NUL-terminated string and no auxiliary data can
+ * be passed.
+ *
+ * Furthermore, it then works as wait_for_key_construction() to wait for the
+ * completion of keys undergoing construction with a non-interruptible wait.
  */
 struct key *request_key(struct key_type *type,
                         const char *description,
@@ -573,12 +626,19 @@ struct key *request_key(struct key_type *type,
 }
 EXPORT_SYMBOL(request_key);
 
-/*
- * request a key with auxiliary data for the upcaller
- * - search the process's keyrings
- * - check the list of keys being created or updated
- * - call out to userspace for a key if supplementary info was provided
- * - waits uninterruptible for creation to complete
+/**
+ * request_key_with_auxdata - Request a key with auxiliary data for the upcaller
+ * @type: The type of key we want.
+ * @description: The searchable description of the key.
+ * @callout_info: The data to pass to the instantiation upcall (or NULL).
+ * @callout_len: The length of callout_info.
+ * @aux: Auxiliary data for the upcall.
+ *
+ * As for request_key_and_link() except that it does not add the returned key
+ * to a keyring if found and new keys are always allocated in the user's quota.
+ *
+ * Furthermore, it then works as wait_for_key_construction() to wait for the
+ * completion of keys undergoing construction with a non-interruptible wait.
  */
 struct key *request_key_with_auxdata(struct key_type *type,
                                      const char *description,
@@ -603,10 +663,18 @@ struct key *request_key_with_auxdata(struct key_type *type,
 EXPORT_SYMBOL(request_key_with_auxdata);
 
 /*
- * request a key (allow async construction)
- * - search the process's keyrings
- * - check the list of keys being created or updated
- * - call out to userspace for a key if supplementary info was provided
+ * request_key_async - Request a key (allow async construction)
+ * @type: Type of key.
+ * @description: The searchable description of the key.
+ * @callout_info: The data to pass to the instantiation upcall (or NULL).
+ * @callout_len: The length of callout_info.
+ *
+ * As for request_key_and_link() except that it does not add the returned key
+ * to a keyring if found, new keys are always allocated in the user's quota and
+ * no auxiliary data can be passed.
+ *
+ * The caller should call wait_for_key_construction() to wait for the
+ * completion of the returned key if it is still undergoing construction.
  */
 struct key *request_key_async(struct key_type *type,
                               const char *description,
@@ -621,9 +689,17 @@ EXPORT_SYMBOL(request_key_async);
 
 /*
  * request a key with auxiliary data for the upcaller (allow async construction)
- * - search the process's keyrings
- * - check the list of keys being created or updated
- * - call out to userspace for a key if supplementary info was provided
+ * @type: Type of key.
+ * @description: The searchable description of the key.
+ * @callout_info: The data to pass to the instantiation upcall (or NULL).
+ * @callout_len: The length of callout_info.
+ * @aux: Auxiliary data for the upcall.
+ *
+ * As for request_key_and_link() except that it does not add the returned key
+ * to a keyring if found and new keys are always allocated in the user's quota.
+ *
+ * The caller should call wait_for_key_construction() to wait for the
+ * completion of the returned key if it is still undergoing construction.
  */
 struct key *request_key_async_with_auxdata(struct key_type *type,
                                            const char *description,
diff --git a/security/keys/request_key_auth.c b/security/keys/request_key_auth.c
index 86747151ee5b..6cff37529b80 100644
--- a/security/keys/request_key_auth.c
+++ b/security/keys/request_key_auth.c
@@ -1,4 +1,4 @@
-/* request_key_auth.c: request key authorisation controlling key def
+/* Request key authorisation token key definition.
  *
  * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
@@ -8,7 +8,7 @@
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  *
- * See Documentation/keys-request-key.txt
+ * See Documentation/security/keys-request-key.txt
  */
 
 #include <linux/module.h>
@@ -26,7 +26,7 @@ static void request_key_auth_destroy(struct key *);
 static long request_key_auth_read(const struct key *, char __user *, size_t);
 
 /*
- * the request-key authorisation key type definition
+ * The request-key authorisation key type definition.
  */
 struct key_type key_type_request_key_auth = {
         .name           = ".request_key_auth",
@@ -38,9 +38,8 @@ struct key_type key_type_request_key_auth = {
         .read           = request_key_auth_read,
 };
 
-/*****************************************************************************/
 /*
- * instantiate a request-key authorisation key
+ * Instantiate a request-key authorisation key.
  */
 static int request_key_auth_instantiate(struct key *key,
                                         const void *data,
@@ -48,12 +47,10 @@ static int request_key_auth_instantiate(struct key *key,
 {
         key->payload.data = (struct request_key_auth *) data;
         return 0;
+}
 
-} /* end request_key_auth_instantiate() */
-
-/*****************************************************************************/
 /*
- * reading a request-key authorisation key retrieves the callout information
+ * Describe an authorisation token.
  */
 static void request_key_auth_describe(const struct key *key,
                                       struct seq_file *m)
@@ -62,13 +59,12 @@ static void request_key_auth_describe(const struct key *key,
 
         seq_puts(m, "key:");
         seq_puts(m, key->description);
-        seq_printf(m, " pid:%d ci:%zu", rka->pid, rka->callout_len);
-
-} /* end request_key_auth_describe() */
+        if (key_is_instantiated(key))
+                seq_printf(m, " pid:%d ci:%zu", rka->pid, rka->callout_len);
+}
 
-/*****************************************************************************/
 /*
- * read the callout_info data
+ * Read the callout_info data (retrieves the callout information).
  * - the key's semaphore is read-locked
  */
 static long request_key_auth_read(const struct key *key,
@@ -91,13 +87,12 @@ static long request_key_auth_read(const struct key *key,
         }
 
         return ret;
+}
 
-} /* end request_key_auth_read() */
-
-/*****************************************************************************/
 /*
- * handle revocation of an authorisation token key
- * - called with the key sem write-locked
+ * Handle revocation of an authorisation token key.
+ *
+ * Called with the key sem write-locked.
  */
 static void request_key_auth_revoke(struct key *key)
 {
@@ -109,12 +104,10 @@ static void request_key_auth_revoke(struct key *key)
                 put_cred(rka->cred);
                 rka->cred = NULL;
         }
+}
 
-} /* end request_key_auth_revoke() */
-
-/*****************************************************************************/
 /*
- * destroy an instantiation authorisation token key
+ * Destroy an instantiation authorisation token key.
  */
 static void request_key_auth_destroy(struct key *key)
 {
@@ -131,13 +124,11 @@ static void request_key_auth_destroy(struct key *key)
         key_put(rka->dest_keyring);
         kfree(rka->callout_info);
         kfree(rka);
+}
 
-} /* end request_key_auth_destroy() */
-
-/*****************************************************************************/
 /*
- * create an authorisation token for /sbin/request-key or whoever to gain
- * access to the caller's security data
+ * 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)
@@ -228,12 +219,10 @@ error_alloc:
         kfree(rka);
         kleave("= %d", ret);
         return ERR_PTR(ret);
+}
 
-} /* end request_key_auth_new() */
-
-/*****************************************************************************/
 /*
- * see if an authorisation key is associated with a particular key
+ * See if an authorisation key is associated with a particular key.
  */
 static int key_get_instantiation_authkey_match(const struct key *key,
                                                const void *_id)
@@ -242,16 +231,11 @@ static int key_get_instantiation_authkey_match(const struct key *key,
         key_serial_t id = (key_serial_t)(unsigned long) _id;
 
         return rka->target_key->serial == id;
+}
 
-} /* end key_get_instantiation_authkey_match() */
-
-/*****************************************************************************/
 /*
- * get the authorisation key for instantiation of a specific key if attached to
- * the current process's keyrings
- * - this key is inserted into a keyring and that is set as /sbin/request-key's
- *   session keyring
- * - a target_id of zero specifies any valid token
+ * Search the current process's keyrings for the authorisation key for
+ * instantiation of a key.
  */
 struct key *key_get_instantiation_authkey(key_serial_t target_id)
 {
@@ -278,5 +262,4 @@ struct key *key_get_instantiation_authkey(key_serial_t target_id)
 
 error:
         return authkey;
-
-} /* end key_get_instantiation_authkey() */
+}
diff --git a/security/keys/trusted.c b/security/keys/trusted.c
new file mode 100644
index 000000000000..0c33e2ea1f3c
--- /dev/null
+++ b/security/keys/trusted.c
@@ -0,0 +1,1180 @@
+/*
+ * Copyright (C) 2010 IBM Corporation
+ *
+ * Author:
+ * David Safford <safford@us.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * See Documentation/security/keys-trusted-encrypted.txt
+ */
+
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/parser.h>
+#include <linux/string.h>
+#include <linux/err.h>
+#include <keys/user-type.h>
+#include <keys/trusted-type.h>
+#include <linux/key-type.h>
+#include <linux/rcupdate.h>
+#include <linux/crypto.h>
+#include <crypto/hash.h>
+#include <crypto/sha.h>
+#include <linux/capability.h>
+#include <linux/tpm.h>
+#include <linux/tpm_command.h>
+
+#include "trusted.h"
+
+static const char hmac_alg[] = "hmac(sha1)";
+static const char hash_alg[] = "sha1";
+
+struct sdesc {
+        struct shash_desc shash;
+        char ctx[];
+};
+
+static struct crypto_shash *hashalg;
+static struct crypto_shash *hmacalg;
+
+static struct sdesc *init_sdesc(struct crypto_shash *alg)
+{
+        struct sdesc *sdesc;
+        int size;
+
+        size = sizeof(struct shash_desc) + crypto_shash_descsize(alg);
+        sdesc = kmalloc(size, GFP_KERNEL);
+        if (!sdesc)
+                return ERR_PTR(-ENOMEM);
+        sdesc->shash.tfm = alg;
+        sdesc->shash.flags = 0x0;
+        return sdesc;
+}
+
+static int TSS_sha1(const unsigned char *data, unsigned int datalen,
+                    unsigned char *digest)
+{
+        struct sdesc *sdesc;
+        int ret;
+
+        sdesc = init_sdesc(hashalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("trusted_key: can't alloc %s\n", hash_alg);
+                return PTR_ERR(sdesc);
+        }
+
+        ret = crypto_shash_digest(&sdesc->shash, data, datalen, digest);
+        kfree(sdesc);
+        return ret;
+}
+
+static int TSS_rawhmac(unsigned char *digest, const unsigned char *key,
+                       unsigned int keylen, ...)
+{
+        struct sdesc *sdesc;
+        va_list argp;
+        unsigned int dlen;
+        unsigned char *data;
+        int ret;
+
+        sdesc = init_sdesc(hmacalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("trusted_key: can't alloc %s\n", hmac_alg);
+                return PTR_ERR(sdesc);
+        }
+
+        ret = crypto_shash_setkey(hmacalg, key, keylen);
+        if (ret < 0)
+                goto out;
+        ret = crypto_shash_init(&sdesc->shash);
+        if (ret < 0)
+                goto out;
+
+        va_start(argp, keylen);
+        for (;;) {
+                dlen = va_arg(argp, unsigned int);
+                if (dlen == 0)
+                        break;
+                data = va_arg(argp, unsigned char *);
+                if (data == NULL) {
+                        ret = -EINVAL;
+                        break;
+                }
+                ret = crypto_shash_update(&sdesc->shash, data, dlen);
+                if (ret < 0)
+                        break;
+        }
+        va_end(argp);
+        if (!ret)
+                ret = crypto_shash_final(&sdesc->shash, digest);
+out:
+        kfree(sdesc);
+        return ret;
+}
+
+/*
+ * calculate authorization info fields to send to TPM
+ */
+static int TSS_authhmac(unsigned char *digest, const unsigned char *key,
+                        unsigned int keylen, unsigned char *h1,
+                        unsigned char *h2, unsigned char h3, ...)
+{
+        unsigned char paramdigest[SHA1_DIGEST_SIZE];
+        struct sdesc *sdesc;
+        unsigned int dlen;
+        unsigned char *data;
+        unsigned char c;
+        int ret;
+        va_list argp;
+
+        sdesc = init_sdesc(hashalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("trusted_key: can't alloc %s\n", hash_alg);
+                return PTR_ERR(sdesc);
+        }
+
+        c = h3;
+        ret = crypto_shash_init(&sdesc->shash);
+        if (ret < 0)
+                goto out;
+        va_start(argp, h3);
+        for (;;) {
+                dlen = va_arg(argp, unsigned int);
+                if (dlen == 0)
+                        break;
+                data = va_arg(argp, unsigned char *);
+                if (!data) {
+                        ret = -EINVAL;
+                        break;
+                }
+                ret = crypto_shash_update(&sdesc->shash, data, dlen);
+                if (ret < 0)
+                        break;
+        }
+        va_end(argp);
+        if (!ret)
+                ret = crypto_shash_final(&sdesc->shash, paramdigest);
+        if (!ret)
+                ret = TSS_rawhmac(digest, key, keylen, SHA1_DIGEST_SIZE,
+                                  paramdigest, TPM_NONCE_SIZE, h1,
+                                  TPM_NONCE_SIZE, h2, 1, &c, 0, 0);
+out:
+        kfree(sdesc);
+        return ret;
+}
+
+/*
+ * verify the AUTH1_COMMAND (Seal) result from TPM
+ */
+static int TSS_checkhmac1(unsigned char *buffer,
+                          const uint32_t command,
+                          const unsigned char *ononce,
+                          const unsigned char *key,
+                          unsigned int keylen, ...)
+{
+        uint32_t bufsize;
+        uint16_t tag;
+        uint32_t ordinal;
+        uint32_t result;
+        unsigned char *enonce;
+        unsigned char *continueflag;
+        unsigned char *authdata;
+        unsigned char testhmac[SHA1_DIGEST_SIZE];
+        unsigned char paramdigest[SHA1_DIGEST_SIZE];
+        struct sdesc *sdesc;
+        unsigned int dlen;
+        unsigned int dpos;
+        va_list argp;
+        int ret;
+
+        bufsize = LOAD32(buffer, TPM_SIZE_OFFSET);
+        tag = LOAD16(buffer, 0);
+        ordinal = command;
+        result = LOAD32N(buffer, TPM_RETURN_OFFSET);
+        if (tag == TPM_TAG_RSP_COMMAND)
+                return 0;
+        if (tag != TPM_TAG_RSP_AUTH1_COMMAND)
+                return -EINVAL;
+        authdata = buffer + bufsize - SHA1_DIGEST_SIZE;
+        continueflag = authdata - 1;
+        enonce = continueflag - TPM_NONCE_SIZE;
+
+        sdesc = init_sdesc(hashalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("trusted_key: can't alloc %s\n", hash_alg);
+                return PTR_ERR(sdesc);
+        }
+        ret = crypto_shash_init(&sdesc->shash);
+        if (ret < 0)
+                goto out;
+        ret = crypto_shash_update(&sdesc->shash, (const u8 *)&result,
+                                  sizeof result);
+        if (ret < 0)
+                goto out;
+        ret = crypto_shash_update(&sdesc->shash, (const u8 *)&ordinal,
+                                  sizeof ordinal);
+        if (ret < 0)
+                goto out;
+        va_start(argp, keylen);
+        for (;;) {
+                dlen = va_arg(argp, unsigned int);
+                if (dlen == 0)
+                        break;
+                dpos = va_arg(argp, unsigned int);
+                ret = crypto_shash_update(&sdesc->shash, buffer + dpos, dlen);
+                if (ret < 0)
+                        break;
+        }
+        va_end(argp);
+        if (!ret)
+                ret = crypto_shash_final(&sdesc->shash, paramdigest);
+        if (ret < 0)
+                goto out;
+
+        ret = TSS_rawhmac(testhmac, key, keylen, SHA1_DIGEST_SIZE, paramdigest,
+                          TPM_NONCE_SIZE, enonce, TPM_NONCE_SIZE, ononce,
+                          1, continueflag, 0, 0);
+        if (ret < 0)
+                goto out;
+
+        if (memcmp(testhmac, authdata, SHA1_DIGEST_SIZE))
+                ret = -EINVAL;
+out:
+        kfree(sdesc);
+        return ret;
+}
+
+/*
+ * verify the AUTH2_COMMAND (unseal) result from TPM
+ */
+static int TSS_checkhmac2(unsigned char *buffer,
+                          const uint32_t command,
+                          const unsigned char *ononce,
+                          const unsigned char *key1,
+                          unsigned int keylen1,
+                          const unsigned char *key2,
+                          unsigned int keylen2, ...)
+{
+        uint32_t bufsize;
+        uint16_t tag;
+        uint32_t ordinal;
+        uint32_t result;
+        unsigned char *enonce1;
+        unsigned char *continueflag1;
+        unsigned char *authdata1;
+        unsigned char *enonce2;
+        unsigned char *continueflag2;
+        unsigned char *authdata2;
+        unsigned char testhmac1[SHA1_DIGEST_SIZE];
+        unsigned char testhmac2[SHA1_DIGEST_SIZE];
+        unsigned char paramdigest[SHA1_DIGEST_SIZE];
+        struct sdesc *sdesc;
+        unsigned int dlen;
+        unsigned int dpos;
+        va_list argp;
+        int ret;
+
+        bufsize = LOAD32(buffer, TPM_SIZE_OFFSET);
+        tag = LOAD16(buffer, 0);
+        ordinal = command;
+        result = LOAD32N(buffer, TPM_RETURN_OFFSET);
+
+        if (tag == TPM_TAG_RSP_COMMAND)
+                return 0;
+        if (tag != TPM_TAG_RSP_AUTH2_COMMAND)
+                return -EINVAL;
+        authdata1 = buffer + bufsize - (SHA1_DIGEST_SIZE + 1
+                        + SHA1_DIGEST_SIZE + SHA1_DIGEST_SIZE);
+        authdata2 = buffer + bufsize - (SHA1_DIGEST_SIZE);
+        continueflag1 = authdata1 - 1;
+        continueflag2 = authdata2 - 1;
+        enonce1 = continueflag1 - TPM_NONCE_SIZE;
+        enonce2 = continueflag2 - TPM_NONCE_SIZE;
+
+        sdesc = init_sdesc(hashalg);
+        if (IS_ERR(sdesc)) {
+                pr_info("trusted_key: can't alloc %s\n", hash_alg);
+                return PTR_ERR(sdesc);
+        }
+        ret = crypto_shash_init(&sdesc->shash);
+        if (ret < 0)
+                goto out;
+        ret = crypto_shash_update(&sdesc->shash, (const u8 *)&result,
+                                  sizeof result);
+        if (ret < 0)
+                goto out;
+        ret = crypto_shash_update(&sdesc->shash, (const u8 *)&ordinal,
+                                  sizeof ordinal);
+        if (ret < 0)
+                goto out;
+
+        va_start(argp, keylen2);
+        for (;;) {
+                dlen = va_arg(argp, unsigned int);
+                if (dlen == 0)
+                        break;
+                dpos = va_arg(argp, unsigned int);
+                ret = crypto_shash_update(&sdesc->shash, buffer + dpos, dlen);
+                if (ret < 0)
+                        break;
+        }
+        va_end(argp);
+        if (!ret)
+                ret = crypto_shash_final(&sdesc->shash, paramdigest);
+        if (ret < 0)
+                goto out;
+
+        ret = TSS_rawhmac(testhmac1, key1, keylen1, SHA1_DIGEST_SIZE,
+                          paramdigest, TPM_NONCE_SIZE, enonce1,
+                          TPM_NONCE_SIZE, ononce, 1, continueflag1, 0, 0);
+        if (ret < 0)
+                goto out;
+        if (memcmp(testhmac1, authdata1, SHA1_DIGEST_SIZE)) {
+                ret = -EINVAL;
+                goto out;
+        }
+        ret = TSS_rawhmac(testhmac2, key2, keylen2, SHA1_DIGEST_SIZE,
+                          paramdigest, TPM_NONCE_SIZE, enonce2,
+                          TPM_NONCE_SIZE, ononce, 1, continueflag2, 0, 0);
+        if (ret < 0)
+                goto out;
+        if (memcmp(testhmac2, authdata2, SHA1_DIGEST_SIZE))
+                ret = -EINVAL;
+out:
+        kfree(sdesc);
+        return ret;
+}
+
+/*
+ * For key specific tpm requests, we will generate and send our
+ * own TPM command packets using the drivers send function.
+ */
+static int trusted_tpm_send(const u32 chip_num, unsigned char *cmd,
+                            size_t buflen)
+{
+        int rc;
+
+        dump_tpm_buf(cmd);
+        rc = tpm_send(chip_num, cmd, buflen);
+        dump_tpm_buf(cmd);
+        if (rc > 0)
+                /* Can't return positive return codes values to keyctl */
+                rc = -EPERM;
+        return rc;
+}
+
+/*
+ * get a random value from TPM
+ */
+static int tpm_get_random(struct tpm_buf *tb, unsigned char *buf, uint32_t len)
+{
+        int ret;
+
+        INIT_BUF(tb);
+        store16(tb, TPM_TAG_RQU_COMMAND);
+        store32(tb, TPM_GETRANDOM_SIZE);
+        store32(tb, TPM_ORD_GETRANDOM);
+        store32(tb, len);
+        ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, sizeof tb->data);
+        if (!ret)
+                memcpy(buf, tb->data + TPM_GETRANDOM_SIZE, len);
+        return ret;
+}
+
+static int my_get_random(unsigned char *buf, int len)
+{
+        struct tpm_buf *tb;
+        int ret;
+
+        tb = kmalloc(sizeof *tb, GFP_KERNEL);
+        if (!tb)
+                return -ENOMEM;
+        ret = tpm_get_random(tb, buf, len);
+
+        kfree(tb);
+        return ret;
+}
+
+/*
+ * Lock a trusted key, by extending a selected PCR.
+ *
+ * Prevents a trusted key that is sealed to PCRs from being accessed.
+ * This uses the tpm driver's extend function.
+ */
+static int pcrlock(const int pcrnum)
+{
+        unsigned char hash[SHA1_DIGEST_SIZE];
+        int ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+        ret = my_get_random(hash, SHA1_DIGEST_SIZE);
+        if (ret < 0)
+                return ret;
+        return tpm_pcr_extend(TPM_ANY_NUM, pcrnum, hash) ? -EINVAL : 0;
+}
+
+/*
+ * Create an object specific authorisation protocol (OSAP) session
+ */
+static int osap(struct tpm_buf *tb, struct osapsess *s,
+                const unsigned char *key, uint16_t type, uint32_t handle)
+{
+        unsigned char enonce[TPM_NONCE_SIZE];
+        unsigned char ononce[TPM_NONCE_SIZE];
+        int ret;
+
+        ret = tpm_get_random(tb, ononce, TPM_NONCE_SIZE);
+        if (ret < 0)
+                return ret;
+
+        INIT_BUF(tb);
+        store16(tb, TPM_TAG_RQU_COMMAND);
+        store32(tb, TPM_OSAP_SIZE);
+        store32(tb, TPM_ORD_OSAP);
+        store16(tb, type);
+        store32(tb, handle);
+        storebytes(tb, ononce, TPM_NONCE_SIZE);
+
+        ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE);
+        if (ret < 0)
+                return ret;
+
+        s->handle = LOAD32(tb->data, TPM_DATA_OFFSET);
+        memcpy(s->enonce, &(tb->data[TPM_DATA_OFFSET + sizeof(uint32_t)]),
+               TPM_NONCE_SIZE);
+        memcpy(enonce, &(tb->data[TPM_DATA_OFFSET + sizeof(uint32_t) +
+                                  TPM_NONCE_SIZE]), TPM_NONCE_SIZE);
+        return TSS_rawhmac(s->secret, key, SHA1_DIGEST_SIZE, TPM_NONCE_SIZE,
+                           enonce, TPM_NONCE_SIZE, ononce, 0, 0);
+}
+
+/*
+ * Create an object independent authorisation protocol (oiap) session
+ */
+static int oiap(struct tpm_buf *tb, uint32_t *handle, unsigned char *nonce)
+{
+        int ret;
+
+        INIT_BUF(tb);
+        store16(tb, TPM_TAG_RQU_COMMAND);
+        store32(tb, TPM_OIAP_SIZE);
+        store32(tb, TPM_ORD_OIAP);
+        ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE);
+        if (ret < 0)
+                return ret;
+
+        *handle = LOAD32(tb->data, TPM_DATA_OFFSET);
+        memcpy(nonce, &tb->data[TPM_DATA_OFFSET + sizeof(uint32_t)],
+               TPM_NONCE_SIZE);
+        return 0;
+}
+
+struct tpm_digests {
+        unsigned char encauth[SHA1_DIGEST_SIZE];
+        unsigned char pubauth[SHA1_DIGEST_SIZE];
+        unsigned char xorwork[SHA1_DIGEST_SIZE * 2];
+        unsigned char xorhash[SHA1_DIGEST_SIZE];
+        unsigned char nonceodd[TPM_NONCE_SIZE];
+};
+
+/*
+ * Have the TPM seal(encrypt) the trusted key, possibly based on
+ * Platform Configuration Registers (PCRs). AUTH1 for sealing key.
+ */
+static int tpm_seal(struct tpm_buf *tb, uint16_t keytype,
+                    uint32_t keyhandle, const unsigned char *keyauth,
+                    const unsigned char *data, uint32_t datalen,
+                    unsigned char *blob, uint32_t *bloblen,
+                    const unsigned char *blobauth,
+                    const unsigned char *pcrinfo, uint32_t pcrinfosize)
+{
+        struct osapsess sess;
+        struct tpm_digests *td;
+        unsigned char cont;
+        uint32_t ordinal;
+        uint32_t pcrsize;
+        uint32_t datsize;
+        int sealinfosize;
+        int encdatasize;
+        int storedsize;
+        int ret;
+        int i;
+
+        /* alloc some work space for all the hashes */
+        td = kmalloc(sizeof *td, GFP_KERNEL);
+        if (!td)
+                return -ENOMEM;
+
+        /* get session for sealing key */
+        ret = osap(tb, &sess, keyauth, keytype, keyhandle);
+        if (ret < 0)
+                goto out;
+        dump_sess(&sess);
+
+        /* calculate encrypted authorization value */
+        memcpy(td->xorwork, sess.secret, SHA1_DIGEST_SIZE);
+        memcpy(td->xorwork + SHA1_DIGEST_SIZE, sess.enonce, SHA1_DIGEST_SIZE);
+        ret = TSS_sha1(td->xorwork, SHA1_DIGEST_SIZE * 2, td->xorhash);
+        if (ret < 0)
+                goto out;
+
+        ret = tpm_get_random(tb, td->nonceodd, TPM_NONCE_SIZE);
+        if (ret < 0)
+                goto out;
+        ordinal = htonl(TPM_ORD_SEAL);
+        datsize = htonl(datalen);
+        pcrsize = htonl(pcrinfosize);
+        cont = 0;
+
+        /* encrypt data authorization key */
+        for (i = 0; i < SHA1_DIGEST_SIZE; ++i)
+                td->encauth[i] = td->xorhash[i] ^ blobauth[i];
+
+        /* calculate authorization HMAC value */
+        if (pcrinfosize == 0) {
+                /* no pcr info specified */
+                ret = TSS_authhmac(td->pubauth, sess.secret, SHA1_DIGEST_SIZE,
+                                   sess.enonce, td->nonceodd, cont,
+                                   sizeof(uint32_t), &ordinal, SHA1_DIGEST_SIZE,
+                                   td->encauth, sizeof(uint32_t), &pcrsize,
+                                   sizeof(uint32_t), &datsize, datalen, data, 0,
+                                   0);
+        } else {
+                /* pcr info specified */
+                ret = TSS_authhmac(td->pubauth, sess.secret, SHA1_DIGEST_SIZE,
+                                   sess.enonce, td->nonceodd, cont,
+                                   sizeof(uint32_t), &ordinal, SHA1_DIGEST_SIZE,
+                                   td->encauth, sizeof(uint32_t), &pcrsize,
+                                   pcrinfosize, pcrinfo, sizeof(uint32_t),
+                                   &datsize, datalen, data, 0, 0);
+        }
+        if (ret < 0)
+                goto out;
+
+        /* build and send the TPM request packet */
+        INIT_BUF(tb);
+        store16(tb, TPM_TAG_RQU_AUTH1_COMMAND);
+        store32(tb, TPM_SEAL_SIZE + pcrinfosize + datalen);
+        store32(tb, TPM_ORD_SEAL);
+        store32(tb, keyhandle);
+        storebytes(tb, td->encauth, SHA1_DIGEST_SIZE);
+        store32(tb, pcrinfosize);
+        storebytes(tb, pcrinfo, pcrinfosize);
+        store32(tb, datalen);
+        storebytes(tb, data, datalen);
+        store32(tb, sess.handle);
+        storebytes(tb, td->nonceodd, TPM_NONCE_SIZE);
+        store8(tb, cont);
+        storebytes(tb, td->pubauth, SHA1_DIGEST_SIZE);
+
+        ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE);
+        if (ret < 0)
+                goto out;
+
+        /* calculate the size of the returned Blob */
+        sealinfosize = LOAD32(tb->data, TPM_DATA_OFFSET + sizeof(uint32_t));
+        encdatasize = LOAD32(tb->data, TPM_DATA_OFFSET + sizeof(uint32_t) +
+                             sizeof(uint32_t) + sealinfosize);
+        storedsize = sizeof(uint32_t) + sizeof(uint32_t) + sealinfosize +
+            sizeof(uint32_t) + encdatasize;
+
+        /* check the HMAC in the response */
+        ret = TSS_checkhmac1(tb->data, ordinal, td->nonceodd, sess.secret,
+                             SHA1_DIGEST_SIZE, storedsize, TPM_DATA_OFFSET, 0,
+                             0);
+
+        /* copy the returned blob to caller */
+        if (!ret) {
+                memcpy(blob, tb->data + TPM_DATA_OFFSET, storedsize);
+                *bloblen = storedsize;
+        }
+out:
+        kfree(td);
+        return ret;
+}
+
+/*
+ * use the AUTH2_COMMAND form of unseal, to authorize both key and blob
+ */
+static int tpm_unseal(struct tpm_buf *tb,
+                      uint32_t keyhandle, const unsigned char *keyauth,
+                      const unsigned char *blob, int bloblen,
+                      const unsigned char *blobauth,
+                      unsigned char *data, unsigned int *datalen)
+{
+        unsigned char nonceodd[TPM_NONCE_SIZE];
+        unsigned char enonce1[TPM_NONCE_SIZE];
+        unsigned char enonce2[TPM_NONCE_SIZE];
+        unsigned char authdata1[SHA1_DIGEST_SIZE];
+        unsigned char authdata2[SHA1_DIGEST_SIZE];
+        uint32_t authhandle1 = 0;
+        uint32_t authhandle2 = 0;
+        unsigned char cont = 0;
+        uint32_t ordinal;
+        uint32_t keyhndl;
+        int ret;
+
+        /* sessions for unsealing key and data */
+        ret = oiap(tb, &authhandle1, enonce1);
+        if (ret < 0) {
+                pr_info("trusted_key: oiap failed (%d)\n", ret);
+                return ret;
+        }
+        ret = oiap(tb, &authhandle2, enonce2);
+        if (ret < 0) {
+                pr_info("trusted_key: oiap failed (%d)\n", ret);
+                return ret;
+        }
+
+        ordinal = htonl(TPM_ORD_UNSEAL);
+        keyhndl = htonl(SRKHANDLE);
+        ret = tpm_get_random(tb, nonceodd, TPM_NONCE_SIZE);
+        if (ret < 0) {
+                pr_info("trusted_key: tpm_get_random failed (%d)\n", ret);
+                return ret;
+        }
+        ret = TSS_authhmac(authdata1, keyauth, TPM_NONCE_SIZE,
+                           enonce1, nonceodd, cont, sizeof(uint32_t),
+                           &ordinal, bloblen, blob, 0, 0);
+        if (ret < 0)
+                return ret;
+        ret = TSS_authhmac(authdata2, blobauth, TPM_NONCE_SIZE,
+                           enonce2, nonceodd, cont, sizeof(uint32_t),
+                           &ordinal, bloblen, blob, 0, 0);
+        if (ret < 0)
+                return ret;
+
+        /* build and send TPM request packet */
+        INIT_BUF(tb);
+        store16(tb, TPM_TAG_RQU_AUTH2_COMMAND);
+        store32(tb, TPM_UNSEAL_SIZE + bloblen);
+        store32(tb, TPM_ORD_UNSEAL);
+        store32(tb, keyhandle);
+        storebytes(tb, blob, bloblen);
+        store32(tb, authhandle1);
+        storebytes(tb, nonceodd, TPM_NONCE_SIZE);
+        store8(tb, cont);
+        storebytes(tb, authdata1, SHA1_DIGEST_SIZE);
+        store32(tb, authhandle2);
+        storebytes(tb, nonceodd, TPM_NONCE_SIZE);
+        store8(tb, cont);
+        storebytes(tb, authdata2, SHA1_DIGEST_SIZE);
+
+        ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE);
+        if (ret < 0) {
+                pr_info("trusted_key: authhmac failed (%d)\n", ret);
+                return ret;
+        }
+
+        *datalen = LOAD32(tb->data, TPM_DATA_OFFSET);
+        ret = TSS_checkhmac2(tb->data, ordinal, nonceodd,
+                             keyauth, SHA1_DIGEST_SIZE,
+                             blobauth, SHA1_DIGEST_SIZE,
+                             sizeof(uint32_t), TPM_DATA_OFFSET,
+                             *datalen, TPM_DATA_OFFSET + sizeof(uint32_t), 0,
+                             0);
+        if (ret < 0) {
+                pr_info("trusted_key: TSS_checkhmac2 failed (%d)\n", ret);
+                return ret;
+        }
+        memcpy(data, tb->data + TPM_DATA_OFFSET + sizeof(uint32_t), *datalen);
+        return 0;
+}
+
+/*
+ * Have the TPM seal(encrypt) the symmetric key
+ */
+static int key_seal(struct trusted_key_payload *p,
+                    struct trusted_key_options *o)
+{
+        struct tpm_buf *tb;
+        int ret;
+
+        tb = kzalloc(sizeof *tb, GFP_KERNEL);
+        if (!tb)
+                return -ENOMEM;
+
+        /* include migratable flag at end of sealed key */
+        p->key[p->key_len] = p->migratable;
+
+        ret = tpm_seal(tb, o->keytype, o->keyhandle, o->keyauth,
+                       p->key, p->key_len + 1, p->blob, &p->blob_len,
+                       o->blobauth, o->pcrinfo, o->pcrinfo_len);
+        if (ret < 0)
+                pr_info("trusted_key: srkseal failed (%d)\n", ret);
+
+        kfree(tb);
+        return ret;
+}
+
+/*
+ * Have the TPM unseal(decrypt) the symmetric key
+ */
+static int key_unseal(struct trusted_key_payload *p,
+                      struct trusted_key_options *o)
+{
+        struct tpm_buf *tb;
+        int ret;
+
+        tb = kzalloc(sizeof *tb, GFP_KERNEL);
+        if (!tb)
+                return -ENOMEM;
+
+        ret = tpm_unseal(tb, o->keyhandle, o->keyauth, p->blob, p->blob_len,
+                         o->blobauth, p->key, &p->key_len);
+        if (ret < 0)
+                pr_info("trusted_key: srkunseal failed (%d)\n", ret);
+        else
+                /* pull migratable flag out of sealed key */
+                p->migratable = p->key[--p->key_len];
+
+        kfree(tb);
+        return ret;
+}
+
+enum {
+        Opt_err = -1,
+        Opt_new, Opt_load, Opt_update,
+        Opt_keyhandle, Opt_keyauth, Opt_blobauth,
+        Opt_pcrinfo, Opt_pcrlock, Opt_migratable
+};
+
+static const match_table_t key_tokens = {
+        {Opt_new, "new"},
+        {Opt_load, "load"},
+        {Opt_update, "update"},
+        {Opt_keyhandle, "keyhandle=%s"},
+        {Opt_keyauth, "keyauth=%s"},
+        {Opt_blobauth, "blobauth=%s"},
+        {Opt_pcrinfo, "pcrinfo=%s"},
+        {Opt_pcrlock, "pcrlock=%s"},
+        {Opt_migratable, "migratable=%s"},
+        {Opt_err, NULL}
+};
+
+/* can have zero or more token= options */
+static int getoptions(char *c, struct trusted_key_payload *pay,
+                      struct trusted_key_options *opt)
+{
+        substring_t args[MAX_OPT_ARGS];
+        char *p = c;
+        int token;
+        int res;
+        unsigned long handle;
+        unsigned long lock;
+
+        while ((p = strsep(&c, " \t"))) {
+                if (*p == '\0' || *p == ' ' || *p == '\t')
+                        continue;
+                token = match_token(p, key_tokens, args);
+
+                switch (token) {
+                case Opt_pcrinfo:
+                        opt->pcrinfo_len = strlen(args[0].from) / 2;
+                        if (opt->pcrinfo_len > MAX_PCRINFO_SIZE)
+                                return -EINVAL;
+                        hex2bin(opt->pcrinfo, args[0].from, opt->pcrinfo_len);
+                        break;
+                case Opt_keyhandle:
+                        res = strict_strtoul(args[0].from, 16, &handle);
+                        if (res < 0)
+                                return -EINVAL;
+                        opt->keytype = SEAL_keytype;
+                        opt->keyhandle = handle;
+                        break;
+                case Opt_keyauth:
+                        if (strlen(args[0].from) != 2 * SHA1_DIGEST_SIZE)
+                                return -EINVAL;
+                        hex2bin(opt->keyauth, args[0].from, SHA1_DIGEST_SIZE);
+                        break;
+                case Opt_blobauth:
+                        if (strlen(args[0].from) != 2 * SHA1_DIGEST_SIZE)
+                                return -EINVAL;
+                        hex2bin(opt->blobauth, args[0].from, SHA1_DIGEST_SIZE);
+                        break;
+                case Opt_migratable:
+                        if (*args[0].from == '0')
+                                pay->migratable = 0;
+                        else
+                                return -EINVAL;
+                        break;
+                case Opt_pcrlock:
+                        res = strict_strtoul(args[0].from, 10, &lock);
+                        if (res < 0)
+                                return -EINVAL;
+                        opt->pcrlock = lock;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
+
+/*
+ * datablob_parse - parse the keyctl data and fill in the
+ *                  payload and options structures
+ *
+ * On success returns 0, otherwise -EINVAL.
+ */
+static int datablob_parse(char *datablob, struct trusted_key_payload *p,
+                          struct trusted_key_options *o)
+{
+        substring_t args[MAX_OPT_ARGS];
+        long keylen;
+        int ret = -EINVAL;
+        int key_cmd;
+        char *c;
+
+        /* main command */
+        c = strsep(&datablob, " \t");
+        if (!c)
+                return -EINVAL;
+        key_cmd = match_token(c, key_tokens, args);
+        switch (key_cmd) {
+        case Opt_new:
+                /* first argument is key size */
+                c = strsep(&datablob, " \t");
+                if (!c)
+                        return -EINVAL;
+                ret = strict_strtol(c, 10, &keylen);
+                if (ret < 0 || keylen < MIN_KEY_SIZE || keylen > MAX_KEY_SIZE)
+                        return -EINVAL;
+                p->key_len = keylen;
+                ret = getoptions(datablob, p, o);
+                if (ret < 0)
+                        return ret;
+                ret = Opt_new;
+                break;
+        case Opt_load:
+                /* first argument is sealed blob */
+                c = strsep(&datablob, " \t");
+                if (!c)
+                        return -EINVAL;
+                p->blob_len = strlen(c) / 2;
+                if (p->blob_len > MAX_BLOB_SIZE)
+                        return -EINVAL;
+                hex2bin(p->blob, c, p->blob_len);
+                ret = getoptions(datablob, p, o);
+                if (ret < 0)
+                        return ret;
+                ret = Opt_load;
+                break;
+        case Opt_update:
+                /* all arguments are options */
+                ret = getoptions(datablob, p, o);
+                if (ret < 0)
+                        return ret;
+                ret = Opt_update;
+                break;
+        case Opt_err:
+                return -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+static struct trusted_key_options *trusted_options_alloc(void)
+{
+        struct trusted_key_options *options;
+
+        options = kzalloc(sizeof *options, GFP_KERNEL);
+        if (options) {
+                /* set any non-zero defaults */
+                options->keytype = SRK_keytype;
+                options->keyhandle = SRKHANDLE;
+        }
+        return options;
+}
+
+static struct trusted_key_payload *trusted_payload_alloc(struct key *key)
+{
+        struct trusted_key_payload *p = NULL;
+        int ret;
+
+        ret = key_payload_reserve(key, sizeof *p);
+        if (ret < 0)
+                return p;
+        p = kzalloc(sizeof *p, GFP_KERNEL);
+        if (p)
+                p->migratable = 1; /* migratable by default */
+        return p;
+}
+
+/*
+ * trusted_instantiate - create a new trusted key
+ *
+ * Unseal an existing trusted blob or, for a new key, get a
+ * random key, then seal and create a trusted key-type key,
+ * adding it to the specified keyring.
+ *
+ * On success, return 0. Otherwise return errno.
+ */
+static int trusted_instantiate(struct key *key, const void *data,
+                               size_t datalen)
+{
+        struct trusted_key_payload *payload = NULL;
+        struct trusted_key_options *options = NULL;
+        char *datablob;
+        int ret = 0;
+        int key_cmd;
+
+        if (datalen <= 0 || datalen > 32767 || !data)
+                return -EINVAL;
+
+        datablob = kmalloc(datalen + 1, GFP_KERNEL);
+        if (!datablob)
+                return -ENOMEM;
+        memcpy(datablob, data, datalen);
+        datablob[datalen] = '\0';
+
+        options = trusted_options_alloc();
+        if (!options) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        payload = trusted_payload_alloc(key);
+        if (!payload) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        key_cmd = datablob_parse(datablob, payload, options);
+        if (key_cmd < 0) {
+                ret = key_cmd;
+                goto out;
+        }
+
+        dump_payload(payload);
+        dump_options(options);
+
+        switch (key_cmd) {
+        case Opt_load:
+                ret = key_unseal(payload, options);
+                dump_payload(payload);
+                dump_options(options);
+                if (ret < 0)
+                        pr_info("trusted_key: key_unseal failed (%d)\n", ret);
+                break;
+        case Opt_new:
+                ret = my_get_random(payload->key, payload->key_len);
+                if (ret < 0) {
+                        pr_info("trusted_key: key_create failed (%d)\n", ret);
+                        goto out;
+                }
+                ret = key_seal(payload, options);
+                if (ret < 0)
+                        pr_info("trusted_key: key_seal failed (%d)\n", ret);
+                break;
+        default:
+                ret = -EINVAL;
+                goto out;
+        }
+        if (!ret && options->pcrlock)
+                ret = pcrlock(options->pcrlock);
+out:
+        kfree(datablob);
+        kfree(options);
+        if (!ret)
+                rcu_assign_pointer(key->payload.data, payload);
+        else
+                kfree(payload);
+        return ret;
+}
+
+static void trusted_rcu_free(struct rcu_head *rcu)
+{
+        struct trusted_key_payload *p;
+
+        p = container_of(rcu, struct trusted_key_payload, rcu);
+        memset(p->key, 0, p->key_len);
+        kfree(p);
+}
+
+/*
+ * trusted_update - reseal an existing key with new PCR values
+ */
+static int trusted_update(struct key *key, const void *data, size_t datalen)
+{
+        struct trusted_key_payload *p = key->payload.data;
+        struct trusted_key_payload *new_p;
+        struct trusted_key_options *new_o;
+        char *datablob;
+        int ret = 0;
+
+        if (!p->migratable)
+                return -EPERM;
+        if (datalen <= 0 || datalen > 32767 || !data)
+                return -EINVAL;
+
+        datablob = kmalloc(datalen + 1, GFP_KERNEL);
+        if (!datablob)
+                return -ENOMEM;
+        new_o = trusted_options_alloc();
+        if (!new_o) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        new_p = trusted_payload_alloc(key);
+        if (!new_p) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memcpy(datablob, data, datalen);
+        datablob[datalen] = '\0';
+        ret = datablob_parse(datablob, new_p, new_o);
+        if (ret != Opt_update) {
+                ret = -EINVAL;
+                kfree(new_p);
+                goto out;
+        }
+        /* copy old key values, and reseal with new pcrs */
+        new_p->migratable = p->migratable;
+        new_p->key_len = p->key_len;
+        memcpy(new_p->key, p->key, p->key_len);
+        dump_payload(p);
+        dump_payload(new_p);
+
+        ret = key_seal(new_p, new_o);
+        if (ret < 0) {
+                pr_info("trusted_key: key_seal failed (%d)\n", ret);
+                kfree(new_p);
+                goto out;
+        }
+        if (new_o->pcrlock) {
+                ret = pcrlock(new_o->pcrlock);
+                if (ret < 0) {
+                        pr_info("trusted_key: pcrlock failed (%d)\n", ret);
+                        kfree(new_p);
+                        goto out;
+                }
+        }
+        rcu_assign_pointer(key->payload.data, new_p);
+        call_rcu(&p->rcu, trusted_rcu_free);
+out:
+        kfree(datablob);
+        kfree(new_o);
+        return ret;
+}
+
+/*
+ * trusted_read - copy the sealed blob data to userspace in hex.
+ * On success, return to userspace the trusted key datablob size.
+ */
+static long trusted_read(const struct key *key, char __user *buffer,
+                         size_t buflen)
+{
+        struct trusted_key_payload *p;
+        char *ascii_buf;
+        char *bufp;
+        int i;
+
+        p = rcu_dereference_key(key);
+        if (!p)
+                return -EINVAL;
+        if (!buffer || buflen <= 0)
+                return 2 * p->blob_len;
+        ascii_buf = kmalloc(2 * p->blob_len, GFP_KERNEL);
+        if (!ascii_buf)
+                return -ENOMEM;
+
+        bufp = ascii_buf;
+        for (i = 0; i < p->blob_len; i++)
+                bufp = pack_hex_byte(bufp, p->blob[i]);
+        if ((copy_to_user(buffer, ascii_buf, 2 * p->blob_len)) != 0) {
+                kfree(ascii_buf);
+                return -EFAULT;
+        }
+        kfree(ascii_buf);
+        return 2 * p->blob_len;
+}
+
+/*
+ * trusted_destroy - before freeing the key, clear the decrypted data
+ */
+static void trusted_destroy(struct key *key)
+{
+        struct trusted_key_payload *p = key->payload.data;
+
+        if (!p)
+                return;
+        memset(p->key, 0, p->key_len);
+        kfree(key->payload.data);
+}
+
+struct key_type key_type_trusted = {
+        .name = "trusted",
+        .instantiate = trusted_instantiate,
+        .update = trusted_update,
+        .match = user_match,
+        .destroy = trusted_destroy,
+        .describe = user_describe,
+        .read = trusted_read,
+};
+
+EXPORT_SYMBOL_GPL(key_type_trusted);
+
+static void trusted_shash_release(void)
+{
+        if (hashalg)
+                crypto_free_shash(hashalg);
+        if (hmacalg)
+                crypto_free_shash(hmacalg);
+}
+
+static int __init trusted_shash_alloc(void)
+{
+        int ret;
+
+        hmacalg = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(hmacalg)) {
+                pr_info("trusted_key: could not allocate crypto %s\n",
+                        hmac_alg);
+                return PTR_ERR(hmacalg);
+        }
+
+        hashalg = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(hashalg)) {
+                pr_info("trusted_key: could not allocate crypto %s\n",
+                        hash_alg);
+                ret = PTR_ERR(hashalg);
+                goto hashalg_fail;
+        }
+
+        return 0;
+
+hashalg_fail:
+        crypto_free_shash(hmacalg);
+        return ret;
+}
+
+static int __init init_trusted(void)
+{
+        int ret;
+
+        ret = trusted_shash_alloc();
+        if (ret < 0)
+                return ret;
+        ret = register_key_type(&key_type_trusted);
+        if (ret < 0)
+                trusted_shash_release();
+        return ret;
+}
+
+static void __exit cleanup_trusted(void)
+{
+        trusted_shash_release();
+        unregister_key_type(&key_type_trusted);
+}
+
+late_initcall(init_trusted);
+module_exit(cleanup_trusted);
+
+MODULE_LICENSE("GPL");
diff --git a/security/keys/trusted.h b/security/keys/trusted.h
new file mode 100644
index 000000000000..3249fbd2b653
--- /dev/null
+++ b/security/keys/trusted.h
@@ -0,0 +1,134 @@
+#ifndef __TRUSTED_KEY_H
+#define __TRUSTED_KEY_H
+
+/* implementation specific TPM constants */
+#define MAX_PCRINFO_SIZE                64
+#define MAX_BUF_SIZE                    512
+#define TPM_GETRANDOM_SIZE              14
+#define TPM_OSAP_SIZE                   36
+#define TPM_OIAP_SIZE                   10
+#define TPM_SEAL_SIZE                   87
+#define TPM_UNSEAL_SIZE                 104
+#define TPM_SIZE_OFFSET                 2
+#define TPM_RETURN_OFFSET               6
+#define TPM_DATA_OFFSET                 10
+
+#define LOAD32(buffer, offset)  (ntohl(*(uint32_t *)&buffer[offset]))
+#define LOAD32N(buffer, offset) (*(uint32_t *)&buffer[offset])
+#define LOAD16(buffer, offset)  (ntohs(*(uint16_t *)&buffer[offset]))
+
+struct tpm_buf {
+        int len;
+        unsigned char data[MAX_BUF_SIZE];
+};
+
+#define INIT_BUF(tb) (tb->len = 0)
+
+struct osapsess {
+        uint32_t handle;
+        unsigned char secret[SHA1_DIGEST_SIZE];
+        unsigned char enonce[TPM_NONCE_SIZE];
+};
+
+/* discrete values, but have to store in uint16_t for TPM use */
+enum {
+        SEAL_keytype = 1,
+        SRK_keytype = 4
+};
+
+struct trusted_key_options {
+        uint16_t keytype;
+        uint32_t keyhandle;
+        unsigned char keyauth[SHA1_DIGEST_SIZE];
+        unsigned char blobauth[SHA1_DIGEST_SIZE];
+        uint32_t pcrinfo_len;
+        unsigned char pcrinfo[MAX_PCRINFO_SIZE];
+        int pcrlock;
+};
+
+#define TPM_DEBUG 0
+
+#if TPM_DEBUG
+static inline void dump_options(struct trusted_key_options *o)
+{
+        pr_info("trusted_key: sealing key type %d\n", o->keytype);
+        pr_info("trusted_key: sealing key handle %0X\n", o->keyhandle);
+        pr_info("trusted_key: pcrlock %d\n", o->pcrlock);
+        pr_info("trusted_key: pcrinfo %d\n", o->pcrinfo_len);
+        print_hex_dump(KERN_INFO, "pcrinfo ", DUMP_PREFIX_NONE,
+                       16, 1, o->pcrinfo, o->pcrinfo_len, 0);
+}
+
+static inline void dump_payload(struct trusted_key_payload *p)
+{
+        pr_info("trusted_key: key_len %d\n", p->key_len);
+        print_hex_dump(KERN_INFO, "key ", DUMP_PREFIX_NONE,
+                       16, 1, p->key, p->key_len, 0);
+        pr_info("trusted_key: bloblen %d\n", p->blob_len);
+        print_hex_dump(KERN_INFO, "blob ", DUMP_PREFIX_NONE,
+                       16, 1, p->blob, p->blob_len, 0);
+        pr_info("trusted_key: migratable %d\n", p->migratable);
+}
+
+static inline void dump_sess(struct osapsess *s)
+{
+        print_hex_dump(KERN_INFO, "trusted-key: handle ", DUMP_PREFIX_NONE,
+                       16, 1, &s->handle, 4, 0);
+        pr_info("trusted-key: secret:\n");
+        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE,
+                       16, 1, &s->secret, SHA1_DIGEST_SIZE, 0);
+        pr_info("trusted-key: enonce:\n");
+        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE,
+                       16, 1, &s->enonce, SHA1_DIGEST_SIZE, 0);
+}
+
+static inline void dump_tpm_buf(unsigned char *buf)
+{
+        int len;
+
+        pr_info("\ntrusted-key: tpm buffer\n");
+        len = LOAD32(buf, TPM_SIZE_OFFSET);
+        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1, buf, len, 0);
+}
+#else
+static inline void dump_options(struct trusted_key_options *o)
+{
+}
+
+static inline void dump_payload(struct trusted_key_payload *p)
+{
+}
+
+static inline void dump_sess(struct osapsess *s)
+{
+}
+
+static inline void dump_tpm_buf(unsigned char *buf)
+{
+}
+#endif
+
+static inline void store8(struct tpm_buf *buf, const unsigned char value)
+{
+        buf->data[buf->len++] = value;
+}
+
+static inline void store16(struct tpm_buf *buf, const uint16_t value)
+{
+        *(uint16_t *) & buf->data[buf->len] = htons(value);
+        buf->len += sizeof value;
+}
+
+static inline void store32(struct tpm_buf *buf, const uint32_t value)
+{
+        *(uint32_t *) & buf->data[buf->len] = htonl(value);
+        buf->len += sizeof value;
+}
+
+static inline void storebytes(struct tpm_buf *buf, const unsigned char *in,
+                              const int len)
+{
+        memcpy(buf->data + buf->len, in, len);
+        buf->len += len;
+}
+#endif
diff --git a/security/keys/user_defined.c b/security/keys/user_defined.c
index e9aa07929656..5b366d7af3c4 100644
--- a/security/keys/user_defined.c
+++ b/security/keys/user_defined.c
@@ -35,7 +35,6 @@ struct key_type key_type_user = {
 
 EXPORT_SYMBOL_GPL(key_type_user);
 
-/*****************************************************************************/
 /*
  * instantiate a user defined key
  */
@@ -65,26 +64,10 @@ int user_instantiate(struct key *key, const void *data, size_t datalen)
 
 error:
         return ret;
-
-} /* end user_instantiate() */
+}
 
 EXPORT_SYMBOL_GPL(user_instantiate);
 
-/*****************************************************************************/
-/*
- * dispose of the old data from an updated user defined key
- */
-static void user_update_rcu_disposal(struct rcu_head *rcu)
-{
-        struct user_key_payload *upayload;
-
-        upayload = container_of(rcu, struct user_key_payload, rcu);
-
-        kfree(upayload);
-
-} /* end user_update_rcu_disposal() */
-
-/*****************************************************************************/
 /*
  * update a user defined key
  * - the key's semaphore is write-locked
@@ -119,28 +102,24 @@ int user_update(struct key *key, const void *data, size_t datalen)
                 key->expiry = 0;
         }
 
-        call_rcu(&zap->rcu, user_update_rcu_disposal);
+        kfree_rcu(zap, rcu);
 
 error:
         return ret;
-
-} /* end user_update() */
+}
 
 EXPORT_SYMBOL_GPL(user_update);
 
-/*****************************************************************************/
 /*
  * match users on their name
  */
 int user_match(const struct key *key, const void *description)
 {
         return strcmp(key->description, description) == 0;
-
-} /* end user_match() */
+}
 
 EXPORT_SYMBOL_GPL(user_match);
 
-/*****************************************************************************/
 /*
  * dispose of the links from a revoked keyring
  * - called with the key sem write-locked
@@ -154,14 +133,12 @@ void user_revoke(struct key *key)
 
         if (upayload) {
                 rcu_assign_pointer(key->payload.data, NULL);
-                call_rcu(&upayload->rcu, user_update_rcu_disposal);
+                kfree_rcu(upayload, rcu);
         }
-
-} /* end user_revoke() */
+}
 
 EXPORT_SYMBOL(user_revoke);
 
-/*****************************************************************************/
 /*
  * dispose of the data dangling from the corpse of a user key
  */
@@ -170,26 +147,22 @@ void user_destroy(struct key *key)
         struct user_key_payload *upayload = key->payload.data;
 
         kfree(upayload);
-
-} /* end user_destroy() */
+}
 
 EXPORT_SYMBOL_GPL(user_destroy);
 
-/*****************************************************************************/
 /*
  * describe the user key
  */
 void user_describe(const struct key *key, struct seq_file *m)
 {
         seq_puts(m, key->description);
-
-        seq_printf(m, ": %u", key->datalen);
-
-} /* end user_describe() */
+        if (key_is_instantiated(key))
+                seq_printf(m, ": %u", key->datalen);
+}
 
 EXPORT_SYMBOL_GPL(user_describe);
 
-/*****************************************************************************/
 /*
  * read the key data
  * - the key's semaphore is read-locked
@@ -199,8 +172,7 @@ long user_read(const struct key *key, char __user *buffer, size_t buflen)
         struct user_key_payload *upayload;
         long ret;
 
-        upayload = rcu_dereference_protected(
-                key->payload.data, rwsem_is_locked(&((struct key *)key)->sem));
+        upayload = rcu_dereference_key(key);
         ret = upayload->datalen;
 
         /* we can return the data as is */
@@ -213,7 +185,6 @@ long user_read(const struct key *key, char __user *buffer, size_t buflen)
         }
 
         return ret;
-
-} /* end user_read() */
+}
 
 EXPORT_SYMBOL_GPL(user_read);