Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security

Pull security subsystem updates from James Morris:
 "In this release:

   - PKCS#7 parser for the key management subsystem from David Howells
   - appoint Kees Cook as seccomp maintainer
   - bugfixes and general maintenance across the subsystem"

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security: (94 commits)
  X.509: Need to export x509_request_asymmetric_key()
  netlabel: shorter names for the NetLabel catmap funcs/structs
  netlabel: fix the catmap walking functions
  netlabel: fix the horribly broken catmap functions
  netlabel: fix a problem when setting bits below the previously lowest bit
  PKCS#7: X.509 certificate issuer and subject are mandatory fields in the ASN.1
  tpm: simplify code by using %*phN specifier
  tpm: Provide a generic means to override the chip returned timeouts
  tpm: missing tpm_chip_put in tpm_get_random()
  tpm: Properly clean sysfs entries in error path
  tpm: Add missing tpm_do_selftest to ST33 I2C driver
  PKCS#7: Use x509_request_asymmetric_key()
  Revert "selinux: fix the default socket labeling in sock_graft()"
  X.509: x509_request_asymmetric_keys() doesn't need string length arguments
  PKCS#7: fix sparse non static symbol warning
  KEYS: revert encrypted key change
  ima: add support for measuring and appraising firmware
  firmware_class: perform new LSM checks
  security: introduce kernel_fw_from_file hook
  PKCS#7: Missing inclusion of linux/err.h
  ...

6 files changed, 145 insertions, 54 deletions

diff --git a/security/keys/big_key.c b/security/keys/big_key.c
index 8137b27d641d..c2f91a0cf889 100644
--- a/security/keys/big_key.c
+++ b/security/keys/big_key.c
@@ -34,7 +34,9 @@ MODULE_LICENSE("GPL");
 struct key_type key_type_big_key = {
         .name                   = "big_key",
         .def_lookup_type        = KEYRING_SEARCH_LOOKUP_DIRECT,
-        .instantiate            = big_key_instantiate,
+        .preparse               = big_key_preparse,
+        .free_preparse          = big_key_free_preparse,
+        .instantiate            = generic_key_instantiate,
         .match                  = user_match,
         .revoke                 = big_key_revoke,
         .destroy                = big_key_destroy,
@@ -43,11 +45,11 @@ struct key_type key_type_big_key = {
 };
 
 /*
- * Instantiate a big key
+ * Preparse a big key
  */
-int big_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
+int big_key_preparse(struct key_preparsed_payload *prep)
 {
-        struct path *path = (struct path *)&key->payload.data2;
+        struct path *path = (struct path *)&prep->payload;
         struct file *file;
         ssize_t written;
         size_t datalen = prep->datalen;
@@ -58,11 +60,9 @@ int big_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
                 goto error;
 
         /* Set an arbitrary quota */
-        ret = key_payload_reserve(key, 16);
-        if (ret < 0)
-                goto error;
+        prep->quotalen = 16;
 
-        key->type_data.x[1] = datalen;
+        prep->type_data[1] = (void *)(unsigned long)datalen;
 
         if (datalen > BIG_KEY_FILE_THRESHOLD) {
                 /* Create a shmem file to store the data in.  This will permit the data
@@ -73,7 +73,7 @@ int big_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
                 file = shmem_kernel_file_setup("", datalen, 0);
                 if (IS_ERR(file)) {
                         ret = PTR_ERR(file);
-                        goto err_quota;
+                        goto error;
                 }
 
                 written = kernel_write(file, prep->data, prep->datalen, 0);
@@ -93,24 +93,33 @@ int big_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
         } else {
                 /* Just store the data in a buffer */
                 void *data = kmalloc(datalen, GFP_KERNEL);
-                if (!data) {
-                        ret = -ENOMEM;
-                        goto err_quota;
-                }
+                if (!data)
+                        return -ENOMEM;
 
-                key->payload.data = memcpy(data, prep->data, prep->datalen);
+                prep->payload[0] = memcpy(data, prep->data, prep->datalen);
         }
         return 0;
 
 err_fput:
         fput(file);
-err_quota:
-        key_payload_reserve(key, 0);
 error:
         return ret;
 }
 
 /*
+ * Clear preparsement.
+ */
+void big_key_free_preparse(struct key_preparsed_payload *prep)
+{
+        if (prep->datalen > BIG_KEY_FILE_THRESHOLD) {
+                struct path *path = (struct path *)&prep->payload;
+                path_put(path);
+        } else {
+                kfree(prep->payload[0]);
+        }
+}
+
+/*
  * dispose of the links from a revoked keyring
  * - called with the key sem write-locked
  */
diff --git a/security/keys/key.c b/security/keys/key.c
index 2048a110e7f1..b90a68c4e2c4 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -437,6 +437,11 @@ static int __key_instantiate_and_link(struct key *key,
                         /* disable the authorisation key */
                         if (authkey)
                                 key_revoke(authkey);
+
+                        if (prep->expiry != TIME_T_MAX) {
+                                key->expiry = prep->expiry;
+                                key_schedule_gc(prep->expiry + key_gc_delay);
+                        }
                 }
         }
 
@@ -479,6 +484,7 @@ int key_instantiate_and_link(struct key *key,
         prep.data = data;
         prep.datalen = datalen;
         prep.quotalen = key->type->def_datalen;
+        prep.expiry = TIME_T_MAX;
         if (key->type->preparse) {
                 ret = key->type->preparse(&prep);
                 if (ret < 0)
@@ -488,7 +494,7 @@ int key_instantiate_and_link(struct key *key,
         if (keyring) {
                 ret = __key_link_begin(keyring, &key->index_key, &edit);
                 if (ret < 0)
-                        goto error_free_preparse;
+                        goto error;
         }
 
         ret = __key_instantiate_and_link(key, &prep, keyring, authkey, &edit);
@@ -496,10 +502,9 @@ int key_instantiate_and_link(struct key *key,
         if (keyring)
                 __key_link_end(keyring, &key->index_key, edit);
 
-error_free_preparse:
+error:
         if (key->type->preparse)
                 key->type->free_preparse(&prep);
-error:
         return ret;
 }
 
@@ -811,11 +816,12 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
         prep.datalen = plen;
         prep.quotalen = index_key.type->def_datalen;
         prep.trusted = flags & KEY_ALLOC_TRUSTED;
+        prep.expiry = TIME_T_MAX;
         if (index_key.type->preparse) {
                 ret = index_key.type->preparse(&prep);
                 if (ret < 0) {
                         key_ref = ERR_PTR(ret);
-                        goto error_put_type;
+                        goto error_free_prep;
                 }
                 if (!index_key.description)
                         index_key.description = prep.description;
@@ -941,6 +947,7 @@ int key_update(key_ref_t key_ref, const void *payload, size_t plen)
         prep.data = payload;
         prep.datalen = plen;
         prep.quotalen = key->type->def_datalen;
+        prep.expiry = TIME_T_MAX;
         if (key->type->preparse) {
                 ret = key->type->preparse(&prep);
                 if (ret < 0)
@@ -956,9 +963,9 @@ int key_update(key_ref_t key_ref, const void *payload, size_t plen)
 
         up_write(&key->sem);
 
+error:
         if (key->type->preparse)
                 key->type->free_preparse(&prep);
-error:
         return ret;
 }
 EXPORT_SYMBOL(key_update);
@@ -1024,6 +1031,38 @@ void key_invalidate(struct key *key)
 EXPORT_SYMBOL(key_invalidate);
 
 /**
+ * generic_key_instantiate - Simple instantiation of a key from preparsed data
+ * @key: The key to be instantiated
+ * @prep: The preparsed data to load.
+ *
+ * Instantiate a key from preparsed data.  We assume we can just copy the data
+ * in directly and clear the old pointers.
+ *
+ * This can be pointed to directly by the key type instantiate op pointer.
+ */
+int generic_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
+{
+        int ret;
+
+        pr_devel("==>%s()\n", __func__);
+
+        ret = key_payload_reserve(key, prep->quotalen);
+        if (ret == 0) {
+                key->type_data.p[0] = prep->type_data[0];
+                key->type_data.p[1] = prep->type_data[1];
+                rcu_assign_keypointer(key, prep->payload[0]);
+                key->payload.data2[1] = prep->payload[1];
+                prep->type_data[0] = NULL;
+                prep->type_data[1] = NULL;
+                prep->payload[0] = NULL;
+                prep->payload[1] = NULL;
+        }
+        pr_devel("<==%s() = %d\n", __func__, ret);
+        return ret;
+}
+EXPORT_SYMBOL(generic_key_instantiate);
+
+/**
  * register_key_type - Register a type of key.
  * @ktype: The new key type.
  *
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index cd5bd0cef25d..e26f860e5f2e 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -37,8 +37,6 @@ static int key_get_type_from_user(char *type,
                 return ret;
         if (ret == 0 || ret >= len)
                 return -EINVAL;
-        if (type[0] == '.')
-                return -EPERM;
         type[len - 1] = '\0';
         return 0;
 }
@@ -86,6 +84,10 @@ SYSCALL_DEFINE5(add_key, const char __user *, _type,
                 if (!*description) {
                         kfree(description);
                         description = NULL;
+                } else if ((description[0] == '.') &&
+                           (strncmp(type, "keyring", 7) == 0)) {
+                        ret = -EPERM;
+                        goto error2;
                 }
         }
 
@@ -404,12 +406,25 @@ long keyctl_invalidate_key(key_serial_t id)
         key_ref = lookup_user_key(id, 0, KEY_NEED_SEARCH);
         if (IS_ERR(key_ref)) {
                 ret = PTR_ERR(key_ref);
+
+                /* Root is permitted to invalidate certain special keys */
+                if (capable(CAP_SYS_ADMIN)) {
+                        key_ref = lookup_user_key(id, 0, 0);
+                        if (IS_ERR(key_ref))
+                                goto error;
+                        if (test_bit(KEY_FLAG_ROOT_CAN_INVAL,
+                                     &key_ref_to_ptr(key_ref)->flags))
+                                goto invalidate;
+                        goto error_put;
+                }
+
                 goto error;
         }
 
+invalidate:
         key_invalidate(key_ref_to_ptr(key_ref));
         ret = 0;
-
+error_put:
         key_ref_put(key_ref);
 error:
         kleave(" = %ld", ret);
diff --git a/security/keys/keyring.c b/security/keys/keyring.c
index 9cf2575f0d97..8314a7d2104d 100644
--- a/security/keys/keyring.c
+++ b/security/keys/keyring.c
@@ -73,6 +73,8 @@ static inline unsigned keyring_hash(const char *desc)
  * can be treated as ordinary keys in addition to having their own special
  * operations.
  */
+static int keyring_preparse(struct key_preparsed_payload *prep);
+static void keyring_free_preparse(struct key_preparsed_payload *prep);
 static int keyring_instantiate(struct key *keyring,
                                struct key_preparsed_payload *prep);
 static void keyring_revoke(struct key *keyring);
@@ -84,6 +86,8 @@ static long keyring_read(const struct key *keyring,
 struct key_type key_type_keyring = {
         .name           = "keyring",
         .def_datalen    = 0,
+        .preparse       = keyring_preparse,
+        .free_preparse  = keyring_free_preparse,
         .instantiate    = keyring_instantiate,
         .match          = user_match,
         .revoke         = keyring_revoke,
@@ -123,6 +127,21 @@ static void keyring_publish_name(struct key *keyring)
 }
 
 /*
+ * Preparse a keyring payload
+ */
+static int keyring_preparse(struct key_preparsed_payload *prep)
+{
+        return prep->datalen != 0 ? -EINVAL : 0;
+}
+
+/*
+ * Free a preparse of a user defined key payload
+ */
+static void keyring_free_preparse(struct key_preparsed_payload *prep)
+{
+}
+
+/*
  * Initialise a keyring.
  *
  * Returns 0 on success, -EINVAL if given any data.
@@ -130,17 +149,10 @@ static void keyring_publish_name(struct key *keyring)
 static int keyring_instantiate(struct key *keyring,
                                struct key_preparsed_payload *prep)
 {
-        int ret;
-
-        ret = -EINVAL;
-        if (prep->datalen == 0) {
-                assoc_array_init(&keyring->keys);
-                /* make the keyring available by name if it has one */
-                keyring_publish_name(keyring);
-                ret = 0;
-        }
-
-        return ret;
+        assoc_array_init(&keyring->keys);
+        /* make the keyring available by name if it has one */
+        keyring_publish_name(keyring);
+        return 0;
 }
 
 /*
diff --git a/security/keys/request_key_auth.c b/security/keys/request_key_auth.c
index 7495a93b4b90..842e6f410d50 100644
--- a/security/keys/request_key_auth.c
+++ b/security/keys/request_key_auth.c
@@ -20,6 +20,8 @@
 #include "internal.h"
 #include <keys/user-type.h>
 
+static int request_key_auth_preparse(struct key_preparsed_payload *);
+static void request_key_auth_free_preparse(struct key_preparsed_payload *);
 static int request_key_auth_instantiate(struct key *,
                                         struct key_preparsed_payload *);
 static void request_key_auth_describe(const struct key *, struct seq_file *);
@@ -33,6 +35,8 @@ static long request_key_auth_read(const struct key *, char __user *, size_t);
 struct key_type key_type_request_key_auth = {
         .name           = ".request_key_auth",
         .def_datalen    = sizeof(struct request_key_auth),
+        .preparse       = request_key_auth_preparse,
+        .free_preparse  = request_key_auth_free_preparse,
         .instantiate    = request_key_auth_instantiate,
         .describe       = request_key_auth_describe,
         .revoke         = request_key_auth_revoke,
@@ -40,6 +44,15 @@ struct key_type key_type_request_key_auth = {
         .read           = request_key_auth_read,
 };
 
+int request_key_auth_preparse(struct key_preparsed_payload *prep)
+{
+        return 0;
+}
+
+void request_key_auth_free_preparse(struct key_preparsed_payload *prep)
+{
+}
+
 /*
  * Instantiate a request-key authorisation key.
  */
diff --git a/security/keys/user_defined.c b/security/keys/user_defined.c
index faa2caeb593f..eee340011f2b 100644
--- a/security/keys/user_defined.c
+++ b/security/keys/user_defined.c
@@ -27,7 +27,9 @@ static int logon_vet_description(const char *desc);
 struct key_type key_type_user = {
         .name                   = "user",
         .def_lookup_type        = KEYRING_SEARCH_LOOKUP_DIRECT,
-        .instantiate            = user_instantiate,
+        .preparse               = user_preparse,
+        .free_preparse          = user_free_preparse,
+        .instantiate            = generic_key_instantiate,
         .update                 = user_update,
         .match                  = user_match,
         .revoke                 = user_revoke,
@@ -47,7 +49,9 @@ EXPORT_SYMBOL_GPL(key_type_user);
 struct key_type key_type_logon = {
         .name                   = "logon",
         .def_lookup_type        = KEYRING_SEARCH_LOOKUP_DIRECT,
-        .instantiate            = user_instantiate,
+        .preparse               = user_preparse,
+        .free_preparse          = user_free_preparse,
+        .instantiate            = generic_key_instantiate,
         .update                 = user_update,
         .match                  = user_match,
         .revoke                 = user_revoke,
@@ -58,38 +62,37 @@ struct key_type key_type_logon = {
 EXPORT_SYMBOL_GPL(key_type_logon);
 
 /*
- * instantiate a user defined key
+ * Preparse a user defined key payload
  */
-int user_instantiate(struct key *key, struct key_preparsed_payload *prep)
+int user_preparse(struct key_preparsed_payload *prep)
 {
         struct user_key_payload *upayload;
         size_t datalen = prep->datalen;
-        int ret;
 
-        ret = -EINVAL;
         if (datalen <= 0 || datalen > 32767 || !prep->data)
-                goto error;
-
-        ret = key_payload_reserve(key, datalen);
-        if (ret < 0)
-                goto error;
+                return -EINVAL;
 
-        ret = -ENOMEM;
         upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
         if (!upayload)
-                goto error;
+                return -ENOMEM;
 
         /* attach the data */
+        prep->quotalen = datalen;
+        prep->payload[0] = upayload;
         upayload->datalen = datalen;
         memcpy(upayload->data, prep->data, datalen);
-        rcu_assign_keypointer(key, upayload);
-        ret = 0;
-
-error:
-        return ret;
+        return 0;
 }
+EXPORT_SYMBOL_GPL(user_preparse);
 
-EXPORT_SYMBOL_GPL(user_instantiate);
+/*
+ * Free a preparse of a user defined key payload
+ */
+void user_free_preparse(struct key_preparsed_payload *prep)
+{
+        kfree(prep->payload[0]);
+}
+EXPORT_SYMBOL_GPL(user_free_preparse);
 
 /*
  * update a user defined key