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

Pull security subsystem updates from James Morris: "In this patchset, we finally get an SELinux update, with Paul Moore taking over as maintainer of that code. Also a significant update for the Keys subsystem, as well as maintenance updates to Smack, IMA, TPM, and Apparmor" and since I wanted to know more about the updates to key handling, here's the explanation from David Howells on that: "Okay. There are a number of separate bits. I'll go over the big bits and the odd important other bit, most of the smaller bits are just fixes and cleanups. If you want the small bits accounting for, I can do that too. (1) Keyring capacity expansion. KEYS: Consolidate the concept of an 'index key' for key access KEYS: Introduce a search context structure KEYS: Search for auth-key by name rather than target key ID Add a generic associative array implementation. KEYS: Expand the capacity of a keyring Several of the patches are providing an expansion of the capacity of a keyring. Currently, the maximum size of a keyring payload is one page. Subtract a small header and then divide up into pointers, that only gives you ~500 pointers on an x86_64 box. However, since the NFS idmapper uses a keyring to store ID mapping data, that has proven to be insufficient to the cause. Whatever data structure I use to handle the keyring payload, it can only store pointers to keys, not the keys themselves because several keyrings may point to a single key. This precludes inserting, say, and rb_node struct into the key struct for this purpose. I could make an rbtree of records such that each record has an rb_node and a key pointer, but that would use four words of space per key stored in the keyring. It would, however, be able to use much existing code. I selected instead a non-rebalancing radix-tree type approach as that could have a better space-used/key-pointer ratio. I could have used the radix tree implementation that we already have and insert keys into it by their serial numbers, but that means any sort of search must iterate over the whole radix tree. Further, its nodes are a bit on the capacious side for what I want - especially given that key serial numbers are randomly allocated, thus leaving a lot of empty space in the tree. So what I have is an associative array that internally is a radix-tree with 16 pointers per node where the index key is constructed from the key type pointer and the key description. This means that an exact lookup by type+description is very fast as this tells us how to navigate directly to the target key. I made the data structure general in lib/assoc_array.c as far as it is concerned, its index key is just a sequence of bits that leads to a pointer. It's possible that someone else will be able to make use of it also. FS-Cache might, for example. (2) Mark keys as 'trusted' and keyrings as 'trusted only'. KEYS: verify a certificate is signed by a 'trusted' key KEYS: Make the system 'trusted' keyring viewable by userspace KEYS: Add a 'trusted' flag and a 'trusted only' flag KEYS: Separate the kernel signature checking keyring from module signing These patches allow keys carrying asymmetric public keys to be marked as being 'trusted' and allow keyrings to be marked as only permitting the addition or linkage of trusted keys. Keys loaded from hardware during kernel boot or compiled into the kernel during build are marked as being trusted automatically. New keys can be loaded at runtime with add_key(). They are checked against the system keyring contents and if their signatures can be validated with keys that are already marked trusted, then they are marked trusted also and can thus be added into the master keyring. Patches from Mimi Zohar make this usable with the IMA keyrings also. (3) Remove the date checks on the key used to validate a module signature. X.509: Remove certificate date checks It's not reasonable to reject a signature just because the key that it was generated with is no longer valid datewise - especially if the kernel hasn't yet managed to set the system clock when the first module is loaded - so just remove those checks. (4) Make it simpler to deal with additional X.509 being loaded into the kernel. KEYS: Load *.x509 files into kernel keyring KEYS: Have make canonicalise the paths of the X.509 certs better to deduplicate The builder of the kernel now just places files with the extension ".x509" into the kernel source or build trees and they're concatenated by the kernel build and stuffed into the appropriate section. (5) Add support for userspace kerberos to use keyrings. KEYS: Add per-user_namespace registers for persistent per-UID kerberos caches KEYS: Implement a big key type that can save to tmpfs Fedora went to, by default, storing kerberos tickets and tokens in tmpfs. We looked at storing it in keyrings instead as that confers certain advantages such as tickets being automatically deleted after a certain amount of time and the ability for the kernel to get at these tokens more easily. To make this work, two things were needed: (a) A way for the tickets to persist beyond the lifetime of all a user's sessions so that cron-driven processes can still use them. The problem is that a user's session keyrings are deleted when the session that spawned them logs out and the user's user keyring is deleted when the UID is deleted (typically when the last log out happens), so neither of these places is suitable. I've added a system keyring into which a 'persistent' keyring is created for each UID on request. Each time a user requests their persistent keyring, the expiry time on it is set anew. If the user doesn't ask for it for, say, three days, the keyring is automatically expired and garbage collected using the existing gc. All the kerberos tokens it held are then also gc'd. (b) A key type that can hold really big tickets (up to 1MB in size). The problem is that Active Directory can return huge tickets with lots of auxiliary data attached. We don't, however, want to eat up huge tracts of unswappable kernel space for this, so if the ticket is greater than a certain size, we create a swappable shmem file and dump the contents in there and just live with the fact we then have an inode and a dentry overhead. If the ticket is smaller than that, we slap it in a kmalloc()'d buffer" * 'for-linus2' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security: (121 commits) KEYS: Fix keyring content gc scanner KEYS: Fix error handling in big_key instantiation KEYS: Fix UID check in keyctl_get_persistent() KEYS: The RSA public key algorithm needs to select MPILIB ima: define '_ima' as a builtin 'trusted' keyring ima: extend the measurement list to include the file signature kernel/system_certificate.S: use real contents instead of macro GLOBAL() KEYS: fix error return code in big_key_instantiate() KEYS: Fix keyring quota misaccounting on key replacement and unlink KEYS: Fix a race between negating a key and reading the error set KEYS: Make BIG_KEYS boolean apparmor: remove the "task" arg from may_change_ptraced_domain() apparmor: remove parent task info from audit logging apparmor: remove tsk field from the apparmor_audit_struct apparmor: fix capability to not use the current task, during reporting Smack: Ptrace access check mode ima: provide hash algo info in the xattr ima: enable support for larger default filedata hash algorithms ima: define kernel parameter 'ima_template=' to change configured default ima: add Kconfig default measurement list template ...
author: Linus Torvalds <torvalds@linux-foundation.org> 2013-11-21 22:46:00 -0500
committer: Linus Torvalds <torvalds@linux-foundation.org> 2013-11-21 22:46:00 -0500
commit: 78dc53c422172a317adb0776dfb687057ffa28b7 (patch)
tree: 7c5d15da75d769d01f6a992c24c3490b3867d5b2 /security
parent: 3eaded86ac3e7f00fb3eeb8162d89e9a34e42fb0 (diff)
parent: 62fe318256befbd1b4a6765e71d9c997f768fe79 (diff)
65 files changed, 3204 insertions, 1596 deletions
diff --git a/security/Makefile b/security/Makefile
index c26c81e92571..a5918e01a4f7 100644
--- a/security/Makefile
+++ b/security/Makefile
@@ -16,7 +16,6 @@ obj-$(CONFIG_MMU)			+= min_addr.o
 # Object file lists
 obj-$(CONFIG_SECURITY)                  += security.o capability.o
 obj-$(CONFIG_SECURITYFS)                += inode.o
-# Must precede capability.o in order to stack properly.
 obj-$(CONFIG_SECURITY_SELINUX)          += selinux/built-in.o
 obj-$(CONFIG_SECURITY_SMACK)            += smack/built-in.o
 obj-$(CONFIG_AUDIT)                     += lsm_audit.o
diff --git a/security/apparmor/audit.c b/security/apparmor/audit.c
index 031d2d9dd695..89c78658031f 100644
--- a/security/apparmor/audit.c
+++ b/security/apparmor/audit.c
@@ -111,7 +111,6 @@ static const char *const aa_audit_type[] = {
 static void audit_pre(struct audit_buffer *ab, void *ca)
 {
        struct common_audit_data *sa = ca;
-        struct task_struct *tsk = sa->aad->tsk ? sa->aad->tsk : current;
        if (aa_g_audit_header) {
                audit_log_format(ab, "apparmor=");
@@ -132,11 +131,6 @@ static void audit_pre(struct audit_buffer *ab, void *ca)
        if (sa->aad->profile) {
                struct aa_profile *profile = sa->aad->profile;
-                pid_t pid;
-                rcu_read_lock();
-                pid = rcu_dereference(tsk->real_parent)->pid;
-                rcu_read_unlock();
-                audit_log_format(ab, " parent=%d", pid);
                if (profile->ns != root_ns) {
                        audit_log_format(ab, " namespace=");
                        audit_log_untrustedstring(ab, profile->ns->base.hname);
@@ -149,12 +143,6 @@ static void audit_pre(struct audit_buffer *ab, void *ca)
                audit_log_format(ab, " name=");
                audit_log_untrustedstring(ab, sa->aad->name);
        }
-        if (sa->aad->tsk) {
-                audit_log_format(ab, " pid=%d comm=", tsk->pid);
-                audit_log_untrustedstring(ab, tsk->comm);
-        }
 }
 /**
@@ -212,7 +200,7 @@ int aa_audit(int type, struct aa_profile *profile, gfp_t gfp,
        if (sa->aad->type == AUDIT_APPARMOR_KILL)
                (void)send_sig_info(SIGKILL, NULL,
-                                    sa->aad->tsk ?  sa->aad->tsk : current);
+                                    sa->u.tsk ?  sa->u.tsk : current);
        if (sa->aad->type == AUDIT_APPARMOR_ALLOWED)
                return complain_error(sa->aad->error);
diff --git a/security/apparmor/capability.c b/security/apparmor/capability.c
index 84d1f5f53877..1101c6f64bb7 100644
--- a/security/apparmor/capability.c
+++ b/security/apparmor/capability.c
@@ -53,8 +53,7 @@ static void audit_cb(struct audit_buffer *ab, void *va)
 /**
 * audit_caps - audit a capability
- * @profile: profile confining task (NOT NULL)
+ * @profile: profile being tested for confinement (NOT NULL)
- * @task: task capability test was performed against (NOT NULL)
 * @cap: capability tested
 * @error: error code returned by test
 *
@@ -63,8 +62,7 @@ static void audit_cb(struct audit_buffer *ab, void *va)
 *
 * Returns: 0 or sa->error on success,  error code on failure
 */
-static int audit_caps(struct aa_profile *profile, struct task_struct *task,
+static int audit_caps(struct aa_profile *profile, int cap, int error)
-                      int cap, int error)
 {
        struct audit_cache *ent;
        int type = AUDIT_APPARMOR_AUTO;
@@ -73,7 +71,6 @@ static int audit_caps(struct aa_profile *profile, struct task_struct *task,
        sa.type = LSM_AUDIT_DATA_CAP;
        sa.aad = &aad;
        sa.u.cap = cap;
-        sa.aad->tsk = task;
        sa.aad->op = OP_CAPABLE;
        sa.aad->error = error;
@@ -124,8 +121,7 @@ static int profile_capable(struct aa_profile *profile, int cap)
 /**
 * aa_capable - test permission to use capability
- * @task: task doing capability test against (NOT NULL)
+ * @profile: profile being tested against (NOT NULL)
- * @profile: profile confining @task (NOT NULL)
 * @cap: capability to be tested
 * @audit: whether an audit record should be generated
 *
@@ -133,8 +129,7 @@ static int profile_capable(struct aa_profile *profile, int cap)
 *
 * Returns: 0 on success, or else an error code.
 */
-int aa_capable(struct task_struct *task, struct aa_profile *profile, int cap,
+int aa_capable(struct aa_profile *profile, int cap, int audit)
-               int audit)
 {
        int error = profile_capable(profile, cap);
@@ -144,5 +139,5 @@ int aa_capable(struct task_struct *task, struct aa_profile *profile, int cap,
                return error;
        }
-        return audit_caps(profile, task, cap, error);
+        return audit_caps(profile, cap, error);
 }
diff --git a/security/apparmor/domain.c b/security/apparmor/domain.c
index 26c607c971f5..452567d3a08e 100644
--- a/security/apparmor/domain.c
+++ b/security/apparmor/domain.c
@@ -50,23 +50,21 @@ void aa_free_domain_entries(struct aa_domain *domain)
 /**
 * may_change_ptraced_domain - check if can change profile on ptraced task
- * @task: task we want to change profile of   (NOT NULL)
 * @to_profile: profile to change to  (NOT NULL)
 *
- * Check if the task is ptraced and if so if the tracing task is allowed
+ * Check if current is ptraced and if so if the tracing task is allowed
 * to trace the new domain
 *
 * Returns: %0 or error if change not allowed
 */
-static int may_change_ptraced_domain(struct task_struct *task,
+static int may_change_ptraced_domain(struct aa_profile *to_profile)
-                                     struct aa_profile *to_profile)
 {
        struct task_struct *tracer;
        struct aa_profile *tracerp = NULL;
        int error = 0;
        rcu_read_lock();
-        tracer = ptrace_parent(task);
+        tracer = ptrace_parent(current);
        if (tracer)
                /* released below */
                tracerp = aa_get_task_profile(tracer);
@@ -75,7 +73,7 @@ static int may_change_ptraced_domain(struct task_struct *task,
        if (!tracer || unconfined(tracerp))
                goto out;
-        error = aa_may_ptrace(tracer, tracerp, to_profile, PTRACE_MODE_ATTACH);
+        error = aa_may_ptrace(tracerp, to_profile, PTRACE_MODE_ATTACH);
 out:
        rcu_read_unlock();
@@ -477,7 +475,7 @@ int apparmor_bprm_set_creds(struct linux_binprm *bprm)
        }
        if (bprm->unsafe & (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
-                error = may_change_ptraced_domain(current, new_profile);
+                error = may_change_ptraced_domain(new_profile);
                if (error) {
                        aa_put_profile(new_profile);
                        goto audit;
@@ -690,7 +688,7 @@ int aa_change_hat(const char *hats[], int count, u64 token, bool permtest)
                        }
                }
-                error = may_change_ptraced_domain(current, hat);
+                error = may_change_ptraced_domain(hat);
                if (error) {
                        info = "ptraced";
                        error = -EPERM;
@@ -829,7 +827,7 @@ int aa_change_profile(const char *ns_name, const char *hname, bool onexec,
        }
        /* check if tracing task is allowed to trace target domain */
-        error = may_change_ptraced_domain(current, target);
+        error = may_change_ptraced_domain(target);
        if (error) {
                info = "ptrace prevents transition";
                goto audit;
diff --git a/security/apparmor/include/audit.h b/security/apparmor/include/audit.h
index 30e8d7687259..ba3dfd17f23f 100644
--- a/security/apparmor/include/audit.h
+++ b/security/apparmor/include/audit.h
@@ -109,7 +109,6 @@ struct apparmor_audit_data {
        void *profile;
        const char *name;
        const char *info;
-        struct task_struct *tsk;
        union {
                void *target;
                struct {
diff --git a/security/apparmor/include/capability.h b/security/apparmor/include/capability.h
index 2e7c9d6a2f3b..fc3fa381d850 100644
--- a/security/apparmor/include/capability.h
+++ b/security/apparmor/include/capability.h
@@ -4,7 +4,7 @@
 * This file contains AppArmor capability mediation definitions.
 *
 * Copyright (C) 1998-2008 Novell/SUSE
- * Copyright 2009-2010 Canonical Ltd.
+ * Copyright 2009-2013 Canonical Ltd.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
@@ -38,8 +38,7 @@ struct aa_caps {
 extern struct aa_fs_entry aa_fs_entry_caps[];
-int aa_capable(struct task_struct *task, struct aa_profile *profile, int cap,
+int aa_capable(struct aa_profile *profile, int cap, int audit);
-               int audit);
 static inline void aa_free_cap_rules(struct aa_caps *caps)
 {
diff --git a/security/apparmor/include/ipc.h b/security/apparmor/include/ipc.h
index aeda0fbc8b2f..288ca76e2fb1 100644
--- a/security/apparmor/include/ipc.h
+++ b/security/apparmor/include/ipc.h
@@ -19,8 +19,8 @@
 struct aa_profile;
-int aa_may_ptrace(struct task_struct *tracer_task, struct aa_profile *tracer,
+int aa_may_ptrace(struct aa_profile *tracer, struct aa_profile *tracee,
-                  struct aa_profile *tracee, unsigned int mode);
+                  unsigned int mode);
 int aa_ptrace(struct task_struct *tracer, struct task_struct *tracee,
              unsigned int mode);
diff --git a/security/apparmor/ipc.c b/security/apparmor/ipc.c
index c51d2266587e..777ac1c47253 100644
--- a/security/apparmor/ipc.c
+++ b/security/apparmor/ipc.c
@@ -54,15 +54,14 @@ static int aa_audit_ptrace(struct aa_profile *profile,
 /**
 * aa_may_ptrace - test if tracer task can trace the tracee
- * @tracer_task: task who will do the tracing  (NOT NULL)
 * @tracer: profile of the task doing the tracing  (NOT NULL)
 * @tracee: task to be traced
 * @mode: whether PTRACE_MODE_READ || PTRACE_MODE_ATTACH
 *
 * Returns: %0 else error code if permission denied or error
 */
-int aa_may_ptrace(struct task_struct *tracer_task, struct aa_profile *tracer,
+int aa_may_ptrace(struct aa_profile *tracer, struct aa_profile *tracee,
-                  struct aa_profile *tracee, unsigned int mode)
+                  unsigned int mode)
 {
        /* TODO: currently only based on capability, not extended ptrace
         *       rules,
@@ -72,7 +71,7 @@ int aa_may_ptrace(struct task_struct *tracer_task, struct aa_profile *tracer,
        if (unconfined(tracer) || tracer == tracee)
                return 0;
        /* log this capability request */
-        return aa_capable(tracer_task, tracer, CAP_SYS_PTRACE, 1);
+        return aa_capable(tracer, CAP_SYS_PTRACE, 1);
 }
 /**
@@ -101,7 +100,7 @@ int aa_ptrace(struct task_struct *tracer, struct task_struct *tracee,
        if (!unconfined(tracer_p)) {
                struct aa_profile *tracee_p = aa_get_task_profile(tracee);
-                error = aa_may_ptrace(tracer, tracer_p, tracee_p, mode);
+                error = aa_may_ptrace(tracer_p, tracee_p, mode);
                error = aa_audit_ptrace(tracer_p, tracee_p, error);
                aa_put_profile(tracee_p);
diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
index fb99e18123b4..4257b7e2796b 100644
--- a/security/apparmor/lsm.c
+++ b/security/apparmor/lsm.c
@@ -145,7 +145,7 @@ static int apparmor_capable(const struct cred *cred, struct user_namespace *ns,
        if (!error) {
                profile = aa_cred_profile(cred);
                if (!unconfined(profile))
-                        error = aa_capable(current, profile, cap, audit);
+                        error = aa_capable(profile, cap, audit);
        }
        return error;
 }
diff --git a/security/capability.c b/security/capability.c
index dbeb9bc27b24..8b4f24ae4338 100644
--- a/security/capability.c
+++ b/security/capability.c
@@ -777,9 +777,15 @@ static int cap_xfrm_policy_delete_security(struct xfrm_sec_ctx *ctx)
        return 0;
 }
-static int cap_xfrm_state_alloc_security(struct xfrm_state *x,
+static int cap_xfrm_state_alloc(struct xfrm_state *x,
-                                         struct xfrm_user_sec_ctx *sec_ctx,
+                                struct xfrm_user_sec_ctx *sec_ctx)
-                                         u32 secid)
+{
+        return 0;
+}
+static int cap_xfrm_state_alloc_acquire(struct xfrm_state *x,
+                                        struct xfrm_sec_ctx *polsec,
+                                        u32 secid)
 {
        return 0;
 }
@@ -1101,7 +1107,8 @@ void __init security_fixup_ops(struct security_operations *ops)
        set_to_cap_if_null(ops, xfrm_policy_clone_security);
        set_to_cap_if_null(ops, xfrm_policy_free_security);
        set_to_cap_if_null(ops, xfrm_policy_delete_security);
-        set_to_cap_if_null(ops, xfrm_state_alloc_security);
+        set_to_cap_if_null(ops, xfrm_state_alloc);
+        set_to_cap_if_null(ops, xfrm_state_alloc_acquire);
        set_to_cap_if_null(ops, xfrm_state_free_security);
        set_to_cap_if_null(ops, xfrm_state_delete_security);
        set_to_cap_if_null(ops, xfrm_policy_lookup);
diff --git a/security/integrity/digsig.c b/security/integrity/digsig.c
index 0b759e17a131..77ca965ab684 100644
--- a/security/integrity/digsig.c
+++ b/security/integrity/digsig.c
@@ -13,7 +13,9 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/err.h>
+#include <linux/sched.h>
 #include <linux/rbtree.h>
+#include <linux/cred.h>
 #include <linux/key-type.h>
 #include <linux/digsig.h>
@@ -21,21 +23,29 @@
 static struct key *keyring[INTEGRITY_KEYRING_MAX];
+#ifdef CONFIG_IMA_TRUSTED_KEYRING
+static const char *keyring_name[INTEGRITY_KEYRING_MAX] = {
+        ".evm",
+        ".module",
+        ".ima",
+};
+#else
 static const char *keyring_name[INTEGRITY_KEYRING_MAX] = {
        "_evm",
        "_module",
        "_ima",
 };
+#endif
 int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,
-                                        const char *digest, int digestlen)
+                            const char *digest, int digestlen)
 {
        if (id >= INTEGRITY_KEYRING_MAX)
                return -EINVAL;
        if (!keyring[id]) {
                keyring[id] =
-                        request_key(&key_type_keyring, keyring_name[id], NULL);
+                    request_key(&key_type_keyring, keyring_name[id], NULL);
                if (IS_ERR(keyring[id])) {
                        int err = PTR_ERR(keyring[id]);
                        pr_err("no %s keyring: %d\n", keyring_name[id], err);
@@ -44,9 +54,10 @@ int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,
                }
        }
-        switch (sig[0]) {
+        switch (sig[1]) {
        case 1:
-                return digsig_verify(keyring[id], sig, siglen,
+                /* v1 API expect signature without xattr type */
+                return digsig_verify(keyring[id], sig + 1, siglen - 1,
                                     digest, digestlen);
        case 2:
                return asymmetric_verify(keyring[id], sig, siglen,
@@ -55,3 +66,21 @@ int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,
        return -EOPNOTSUPP;
 }
+int integrity_init_keyring(const unsigned int id)
+{
+        const struct cred *cred = current_cred();
+        const struct user_struct *user = cred->user;
+        keyring[id] = keyring_alloc(keyring_name[id], KUIDT_INIT(0),
+                                    KGIDT_INIT(0), cred,
+                                    ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
+                                     KEY_USR_VIEW | KEY_USR_READ),
+                                    KEY_ALLOC_NOT_IN_QUOTA, user->uid_keyring);
+        if (!IS_ERR(keyring[id]))
+                set_bit(KEY_FLAG_TRUSTED_ONLY, &keyring[id]->flags);
+        else
+                pr_info("Can't allocate %s keyring (%ld)\n",
+                        keyring_name[id], PTR_ERR(keyring[id]));
+        return 0;
+}
diff --git a/security/integrity/digsig_asymmetric.c b/security/integrity/digsig_asymmetric.c
index b4754667659d..9eae4809006b 100644
--- a/security/integrity/digsig_asymmetric.c
+++ b/security/integrity/digsig_asymmetric.c
@@ -20,17 +20,6 @@
 #include "integrity.h"
 /*
- * signature format v2 - for using with asymmetric keys
- */
-struct signature_v2_hdr {
-        uint8_t version;        /* signature format version */
-        uint8_t hash_algo;      /* Digest algorithm [enum pkey_hash_algo] */
-        uint32_t keyid;         /* IMA key identifier - not X509/PGP specific*/
-        uint16_t sig_size;      /* signature size */
-        uint8_t sig[0];         /* signature payload */
-} __packed;
-/*
 * Request an asymmetric key.
 */
 static struct key *request_asymmetric_key(struct key *keyring, uint32_t keyid)
diff --git a/security/integrity/evm/evm_main.c b/security/integrity/evm/evm_main.c
index af9b6852f4e1..336b3ddfe63f 100644
--- a/security/integrity/evm/evm_main.c
+++ b/security/integrity/evm/evm_main.c
@@ -123,7 +123,7 @@ static enum integrity_status evm_verify_hmac(struct dentry *dentry,
                goto out;
        }
-        xattr_len = rc - 1;
+        xattr_len = rc;
        /* check value type */
        switch (xattr_data->type) {
@@ -143,7 +143,7 @@ static enum integrity_status evm_verify_hmac(struct dentry *dentry,
                if (rc)
                        break;
                rc = integrity_digsig_verify(INTEGRITY_KEYRING_EVM,
-                                        xattr_data->digest, xattr_len,
+                                        (const char *)xattr_data, xattr_len,
                                        calc.digest, sizeof(calc.digest));
                if (!rc) {
                        /* we probably want to replace rsa with hmac here */
diff --git a/security/integrity/evm/evm_posix_acl.c b/security/integrity/evm/evm_posix_acl.c
index b1753e98bf9a..46408b9e62e8 100644
--- a/security/integrity/evm/evm_posix_acl.c
+++ b/security/integrity/evm/evm_posix_acl.c
@@ -11,8 +11,9 @@
 #include <linux/module.h>
 #include <linux/xattr.h>
+#include <linux/evm.h>
-int posix_xattr_acl(char *xattr)
+int posix_xattr_acl(const char *xattr)
 {
        int xattr_len = strlen(xattr);
diff --git a/security/integrity/iint.c b/security/integrity/iint.c
index 74522dbd10a6..c49d3f14cbec 100644
--- a/security/integrity/iint.c
+++ b/security/integrity/iint.c
@@ -70,6 +70,8 @@ struct integrity_iint_cache *integrity_iint_find(struct inode *inode)
 static void iint_free(struct integrity_iint_cache *iint)
 {
+        kfree(iint->ima_hash);
+        iint->ima_hash = NULL;
        iint->version = 0;
        iint->flags = 0UL;
        iint->ima_file_status = INTEGRITY_UNKNOWN;
diff --git a/security/integrity/ima/Kconfig b/security/integrity/ima/Kconfig
index 39196abaff0d..dad8d4ca2437 100644
--- a/security/integrity/ima/Kconfig
+++ b/security/integrity/ima/Kconfig
@@ -9,6 +9,7 @@ config IMA
        select CRYPTO_HMAC
        select CRYPTO_MD5
        select CRYPTO_SHA1
+        select CRYPTO_HASH_INFO
        select TCG_TPM if HAS_IOMEM && !UML
        select TCG_TIS if TCG_TPM && X86
        select TCG_IBMVTPM if TCG_TPM && PPC64
@@ -45,6 +46,69 @@ config IMA_LSM_RULES
        help
          Disabling this option will disregard LSM based policy rules.
+choice
+        prompt "Default template"
+        default IMA_NG_TEMPLATE
+        depends on IMA
+        help
+          Select the default IMA measurement template.
+          The original 'ima' measurement list template contains a
+          hash, defined as 20 bytes, and a null terminated pathname,
+          limited to 255 characters.  The 'ima-ng' measurement list
+          template permits both larger hash digests and longer
+          pathnames.
+        config IMA_TEMPLATE
+                bool "ima"
+        config IMA_NG_TEMPLATE
+                bool "ima-ng (default)"
+        config IMA_SIG_TEMPLATE
+                bool "ima-sig"
+endchoice
+config IMA_DEFAULT_TEMPLATE
+        string
+        depends on IMA
+        default "ima" if IMA_TEMPLATE
+        default "ima-ng" if IMA_NG_TEMPLATE
+        default "ima-sig" if IMA_SIG_TEMPLATE
+choice
+        prompt "Default integrity hash algorithm"
+        default IMA_DEFAULT_HASH_SHA1
+        depends on IMA
+        help
+           Select the default hash algorithm used for the measurement
+           list, integrity appraisal and audit log.  The compiled default
+           hash algorithm can be overwritten using the kernel command
+           line 'ima_hash=' option.
+        config IMA_DEFAULT_HASH_SHA1
+                bool "SHA1 (default)"
+                depends on CRYPTO_SHA1
+        config IMA_DEFAULT_HASH_SHA256
+                bool "SHA256"
+                depends on CRYPTO_SHA256 && !IMA_TEMPLATE
+        config IMA_DEFAULT_HASH_SHA512
+                bool "SHA512"
+                depends on CRYPTO_SHA512 && !IMA_TEMPLATE
+        config IMA_DEFAULT_HASH_WP512
+                bool "WP512"
+                depends on CRYPTO_WP512 && !IMA_TEMPLATE
+endchoice
+config IMA_DEFAULT_HASH
+        string
+        depends on IMA
+        default "sha1" if IMA_DEFAULT_HASH_SHA1
+        default "sha256" if IMA_DEFAULT_HASH_SHA256
+        default "sha512" if IMA_DEFAULT_HASH_SHA512
+        default "wp512" if IMA_DEFAULT_HASH_WP512
 config IMA_APPRAISE
        bool "Appraise integrity measurements"
        depends on IMA
@@ -59,3 +123,11 @@ config IMA_APPRAISE
          For more information on integrity appraisal refer to:
          <http://linux-ima.sourceforge.net>
          If unsure, say N.
+config IMA_TRUSTED_KEYRING
+        bool "Require all keys on the _ima keyring be signed"
+        depends on IMA_APPRAISE && SYSTEM_TRUSTED_KEYRING
+        default y
+        help
+           This option requires that all keys added to the _ima
+           keyring be signed by a key on the system trusted keyring.
diff --git a/security/integrity/ima/Makefile b/security/integrity/ima/Makefile
index 56dfee7cbf61..d79263d2fdbf 100644
--- a/security/integrity/ima/Makefile
+++ b/security/integrity/ima/Makefile
@@ -6,5 +6,5 @@
 obj-$(CONFIG_IMA) += ima.o
 ima-y := ima_fs.o ima_queue.o ima_init.o ima_main.o ima_crypto.o ima_api.o \
-         ima_policy.o
+         ima_policy.o ima_template.o ima_template_lib.o
 ima-$(CONFIG_IMA_APPRAISE) += ima_appraise.o
diff --git a/security/integrity/ima/ima.h b/security/integrity/ima/ima.h
index b3dd616560f7..bf03c6a16cc8 100644
--- a/security/integrity/ima/ima.h
+++ b/security/integrity/ima/ima.h
@@ -36,23 +36,48 @@ enum tpm_pcrs { TPM_PCR0 = 0, TPM_PCR8 = 8 };
 #define IMA_HASH_BITS 9
 #define IMA_MEASURE_HTABLE_SIZE (1 << IMA_HASH_BITS)
+#define IMA_TEMPLATE_FIELD_ID_MAX_LEN   16
+#define IMA_TEMPLATE_NUM_FIELDS_MAX     15
+#define IMA_TEMPLATE_IMA_NAME "ima"
+#define IMA_TEMPLATE_IMA_FMT "d|n"
 /* set during initialization */
 extern int ima_initialized;
 extern int ima_used_chip;
-extern char *ima_hash;
+extern int ima_hash_algo;
 extern int ima_appraise;
-/* IMA inode template definition */
+/* IMA template field data definition */
-struct ima_template_data {
+struct ima_field_data {
-        u8 digest[IMA_DIGEST_SIZE];     /* sha1/md5 measurement hash */
+        u8 *data;
-        char file_name[IMA_EVENT_NAME_LEN_MAX + 1];     /* name + \0 */
+        u32 len;
+};
+/* IMA template field definition */
+struct ima_template_field {
+        const char field_id[IMA_TEMPLATE_FIELD_ID_MAX_LEN];
+        int (*field_init) (struct integrity_iint_cache *iint, struct file *file,
+                           const unsigned char *filename,
+                           struct evm_ima_xattr_data *xattr_value,
+                           int xattr_len, struct ima_field_data *field_data);
+        void (*field_show) (struct seq_file *m, enum ima_show_type show,
+                            struct ima_field_data *field_data);
+};
+/* IMA template descriptor definition */
+struct ima_template_desc {
+        char *name;
+        char *fmt;
+        int num_fields;
+        struct ima_template_field **fields;
 };
 struct ima_template_entry {
-        u8 digest[IMA_DIGEST_SIZE];     /* sha1 or md5 measurement hash */
+        u8 digest[TPM_DIGEST_SIZE];     /* sha1 or md5 measurement hash */
-        const char *template_name;
+        struct ima_template_desc *template_desc; /* template descriptor */
-        int template_len;
+        u32 template_data_len;
-        struct ima_template_data template;
+        struct ima_field_data template_data[0]; /* template related data */
 };
 struct ima_queue_entry {
@@ -69,13 +94,21 @@ int ima_fs_init(void);
 void ima_fs_cleanup(void);
 int ima_inode_alloc(struct inode *inode);
 int ima_add_template_entry(struct ima_template_entry *entry, int violation,
-                           const char *op, struct inode *inode);
+                           const char *op, struct inode *inode,
-int ima_calc_file_hash(struct file *file, char *digest);
+                           const unsigned char *filename);
-int ima_calc_buffer_hash(const void *data, int len, char *digest);
+int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash);
-int ima_calc_boot_aggregate(char *digest);
+int ima_calc_field_array_hash(struct ima_field_data *field_data, int num_fields,
-void ima_add_violation(struct inode *inode, const unsigned char *filename,
+                              struct ima_digest_data *hash);
+int __init ima_calc_boot_aggregate(struct ima_digest_data *hash);
+void ima_add_violation(struct file *file, const unsigned char *filename,
                       const char *op, const char *cause);
 int ima_init_crypto(void);
+void ima_putc(struct seq_file *m, void *data, int datalen);
+void ima_print_digest(struct seq_file *m, u8 *digest, int size);
+struct ima_template_desc *ima_template_desc_current(void);
+int ima_init_template(void);
+int ima_init_template(void);
 /*
 * used to protect h_table and sha_table
@@ -98,14 +131,21 @@ static inline unsigned long ima_hash_key(u8 *digest)
 int ima_get_action(struct inode *inode, int mask, int function);
 int ima_must_measure(struct inode *inode, int mask, int function);
 int ima_collect_measurement(struct integrity_iint_cache *iint,
-                            struct file *file);
+                            struct file *file,
+                            struct evm_ima_xattr_data **xattr_value,
+                            int *xattr_len);
 void ima_store_measurement(struct integrity_iint_cache *iint, struct file *file,
-                           const unsigned char *filename);
+                           const unsigned char *filename,
+                           struct evm_ima_xattr_data *xattr_value,
+                           int xattr_len);
 void ima_audit_measurement(struct integrity_iint_cache *iint,
                           const unsigned char *filename);
+int ima_alloc_init_template(struct integrity_iint_cache *iint,
+                            struct file *file, const unsigned char *filename,
+                            struct evm_ima_xattr_data *xattr_value,
+                            int xattr_len, struct ima_template_entry **entry);
 int ima_store_template(struct ima_template_entry *entry, int violation,
-                       struct inode *inode);
+                       struct inode *inode, const unsigned char *filename);
-void ima_template_show(struct seq_file *m, void *e, enum ima_show_type show);
 const char *ima_d_path(struct path *path, char **pathbuf);
 /* rbtree tree calls to lookup, insert, delete
@@ -131,17 +171,25 @@ void ima_delete_rules(void);
 #ifdef CONFIG_IMA_APPRAISE
 int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
-                             struct file *file, const unsigned char *filename);
+                             struct file *file, const unsigned char *filename,
+                             struct evm_ima_xattr_data *xattr_value,
+                             int xattr_len);
 int ima_must_appraise(struct inode *inode, int mask, enum ima_hooks func);
 void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file);
 enum integrity_status ima_get_cache_status(struct integrity_iint_cache *iint,
                                           int func);
+void ima_get_hash_algo(struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                       struct ima_digest_data *hash);
+int ima_read_xattr(struct dentry *dentry,
+                   struct evm_ima_xattr_data **xattr_value);
 #else
 static inline int ima_appraise_measurement(int func,
                                           struct integrity_iint_cache *iint,
                                           struct file *file,
-                                           const unsigned char *filename)
+                                           const unsigned char *filename,
+                                           struct evm_ima_xattr_data *xattr_value,
+                                           int xattr_len)
 {
        return INTEGRITY_UNKNOWN;
 }
@@ -162,6 +210,19 @@ static inline enum integrity_status ima_get_cache_status(struct integrity_iint_c
 {
        return INTEGRITY_UNKNOWN;
 }
+static inline void ima_get_hash_algo(struct evm_ima_xattr_data *xattr_value,
+                                     int xattr_len,
+                                     struct ima_digest_data *hash)
+{
+}
+static inline int ima_read_xattr(struct dentry *dentry,
+                                 struct evm_ima_xattr_data **xattr_value)
+{
+        return 0;
+}
 #endif
 /* LSM based policy rules require audit */
diff --git a/security/integrity/ima/ima_api.c b/security/integrity/ima/ima_api.c
index 1c03e8f1e0e1..0e7540863fc2 100644
--- a/security/integrity/ima/ima_api.c
+++ b/security/integrity/ima/ima_api.c
@@ -18,9 +18,46 @@
 #include <linux/fs.h>
 #include <linux/xattr.h>
 #include <linux/evm.h>
+#include <crypto/hash_info.h>
 #include "ima.h"
-static const char *IMA_TEMPLATE_NAME = "ima";
+/*
+ * ima_alloc_init_template - create and initialize a new template entry
+ */
+int ima_alloc_init_template(struct integrity_iint_cache *iint,
+                            struct file *file, const unsigned char *filename,
+                            struct evm_ima_xattr_data *xattr_value,
+                            int xattr_len, struct ima_template_entry **entry)
+{
+        struct ima_template_desc *template_desc = ima_template_desc_current();
+        int i, result = 0;
+        *entry = kzalloc(sizeof(**entry) + template_desc->num_fields *
+                         sizeof(struct ima_field_data), GFP_NOFS);
+        if (!*entry)
+                return -ENOMEM;
+        for (i = 0; i < template_desc->num_fields; i++) {
+                struct ima_template_field *field = template_desc->fields[i];
+                u32 len;
+                result = field->field_init(iint, file, filename,
+                                           xattr_value, xattr_len,
+                                           &((*entry)->template_data[i]));
+                if (result != 0)
+                        goto out;
+                len = (*entry)->template_data[i].len;
+                (*entry)->template_data_len += sizeof(len);
+                (*entry)->template_data_len += len;
+        }
+        (*entry)->template_desc = template_desc;
+        return 0;
+out:
+        kfree(*entry);
+        *entry = NULL;
+        return result;
+}
 /*
 * ima_store_template - store ima template measurements
@@ -39,28 +76,34 @@ static const char *IMA_TEMPLATE_NAME = "ima";
 * Returns 0 on success, error code otherwise
 */
 int ima_store_template(struct ima_template_entry *entry,
-                       int violation, struct inode *inode)
+                       int violation, struct inode *inode,
+                       const unsigned char *filename)
 {
        const char *op = "add_template_measure";
        const char *audit_cause = "hashing_error";
+        char *template_name = entry->template_desc->name;
        int result;
+        struct {
-        memset(entry->digest, 0, sizeof(entry->digest));
+                struct ima_digest_data hdr;
-        entry->template_name = IMA_TEMPLATE_NAME;
+                char digest[TPM_DIGEST_SIZE];
-        entry->template_len = sizeof(entry->template);
+        } hash;
        if (!violation) {
-                result = ima_calc_buffer_hash(&entry->template,
+                int num_fields = entry->template_desc->num_fields;
-                                                entry->template_len,
-                                                entry->digest);
+                /* this function uses default algo */
+                hash.hdr.algo = HASH_ALGO_SHA1;
+                result = ima_calc_field_array_hash(&entry->template_data[0],
+                                                   num_fields, &hash.hdr);
                if (result < 0) {
                        integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
-                                            entry->template_name, op,
+                                            template_name, op,
                                            audit_cause, result, 0);
                        return result;
                }
+                memcpy(entry->digest, hash.hdr.digest, hash.hdr.length);
        }
-        result = ima_add_template_entry(entry, violation, op, inode);
+        result = ima_add_template_entry(entry, violation, op, inode, filename);
        return result;
 }
@@ -71,24 +114,24 @@ int ima_store_template(struct ima_template_entry *entry,
 * By extending the PCR with 0xFF's instead of with zeroes, the PCR
 * value is invalidated.
 */
-void ima_add_violation(struct inode *inode, const unsigned char *filename,
+void ima_add_violation(struct file *file, const unsigned char *filename,
                       const char *op, const char *cause)
 {
        struct ima_template_entry *entry;
+        struct inode *inode = file->f_dentry->d_inode;
        int violation = 1;
        int result;
        /* can overflow, only indicator */
        atomic_long_inc(&ima_htable.violations);
-        entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+        result = ima_alloc_init_template(NULL, file, filename,
-        if (!entry) {
+                                         NULL, 0, &entry);
+        if (result < 0) {
                result = -ENOMEM;
                goto err_out;
        }
-        memset(&entry->template, 0, sizeof(entry->template));
+        result = ima_store_template(entry, violation, inode, filename);
-        strncpy(entry->template.file_name, filename, IMA_EVENT_NAME_LEN_MAX);
-        result = ima_store_template(entry, violation, inode);
        if (result < 0)
                kfree(entry);
 err_out:
@@ -138,20 +181,42 @@ int ima_must_measure(struct inode *inode, int mask, int function)
 * Return 0 on success, error code otherwise
 */
 int ima_collect_measurement(struct integrity_iint_cache *iint,
-                            struct file *file)
+                            struct file *file,
+                            struct evm_ima_xattr_data **xattr_value,
+                            int *xattr_len)
 {
        struct inode *inode = file_inode(file);
        const char *filename = file->f_dentry->d_name.name;
        int result = 0;
+        struct {
+                struct ima_digest_data hdr;
+                char digest[IMA_MAX_DIGEST_SIZE];
+        } hash;
+        if (xattr_value)
+                *xattr_len = ima_read_xattr(file->f_dentry, xattr_value);
        if (!(iint->flags & IMA_COLLECTED)) {
                u64 i_version = file_inode(file)->i_version;
-                iint->ima_xattr.type = IMA_XATTR_DIGEST;
+                /* use default hash algorithm */
-                result = ima_calc_file_hash(file, iint->ima_xattr.digest);
+                hash.hdr.algo = ima_hash_algo;
+                if (xattr_value)
+                        ima_get_hash_algo(*xattr_value, *xattr_len, &hash.hdr);
+                result = ima_calc_file_hash(file, &hash.hdr);
                if (!result) {
-                        iint->version = i_version;
+                        int length = sizeof(hash.hdr) + hash.hdr.length;
-                        iint->flags |= IMA_COLLECTED;
+                        void *tmpbuf = krealloc(iint->ima_hash, length,
+                                                GFP_NOFS);
+                        if (tmpbuf) {
+                                iint->ima_hash = tmpbuf;
+                                memcpy(iint->ima_hash, &hash, length);
+                                iint->version = i_version;
+                                iint->flags |= IMA_COLLECTED;
+                        } else
+                                result = -ENOMEM;
                }
        }
        if (result)
@@ -177,7 +242,9 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,
 * Must be called with iint->mutex held.
 */
 void ima_store_measurement(struct integrity_iint_cache *iint,
-                           struct file *file, const unsigned char *filename)
+                           struct file *file, const unsigned char *filename,
+                           struct evm_ima_xattr_data *xattr_value,
+                           int xattr_len)
 {
        const char *op = "add_template_measure";
        const char *audit_cause = "ENOMEM";
@@ -189,19 +256,15 @@ void ima_store_measurement(struct integrity_iint_cache *iint,
        if (iint->flags & IMA_MEASURED)
                return;
-        entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+        result = ima_alloc_init_template(iint, file, filename,
-        if (!entry) {
+                                         xattr_value, xattr_len, &entry);
+        if (result < 0) {
                integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
                                    op, audit_cause, result, 0);
                return;
        }
-        memset(&entry->template, 0, sizeof(entry->template));
-        memcpy(entry->template.digest, iint->ima_xattr.digest, IMA_DIGEST_SIZE);
-        strcpy(entry->template.file_name,
-               (strlen(filename) > IMA_EVENT_NAME_LEN_MAX) ?
-               file->f_dentry->d_name.name : filename);
-        result = ima_store_template(entry, violation, inode);
+        result = ima_store_template(entry, violation, inode, filename);
        if (!result || result == -EEXIST)
                iint->flags |= IMA_MEASURED;
        if (result < 0)
@@ -212,14 +275,16 @@ void ima_audit_measurement(struct integrity_iint_cache *iint,
                           const unsigned char *filename)
 {
        struct audit_buffer *ab;
-        char hash[(IMA_DIGEST_SIZE * 2) + 1];
+        char hash[(iint->ima_hash->length * 2) + 1];
+        const char *algo_name = hash_algo_name[iint->ima_hash->algo];
+        char algo_hash[sizeof(hash) + strlen(algo_name) + 2];
        int i;
        if (iint->flags & IMA_AUDITED)
                return;
-        for (i = 0; i < IMA_DIGEST_SIZE; i++)
+        for (i = 0; i < iint->ima_hash->length; i++)
-                hex_byte_pack(hash + (i * 2), iint->ima_xattr.digest[i]);
+                hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
        hash[i * 2] = '\0';
        ab = audit_log_start(current->audit_context, GFP_KERNEL,
@@ -230,7 +295,8 @@ void ima_audit_measurement(struct integrity_iint_cache *iint,
        audit_log_format(ab, "file=");
        audit_log_untrustedstring(ab, filename);
        audit_log_format(ab, " hash=");
-        audit_log_untrustedstring(ab, hash);
+        snprintf(algo_hash, sizeof(algo_hash), "%s:%s", algo_name, hash);
+        audit_log_untrustedstring(ab, algo_hash);
        audit_log_task_info(ab, current);
        audit_log_end(ab);
diff --git a/security/integrity/ima/ima_appraise.c b/security/integrity/ima/ima_appraise.c
index 2d4becab8918..46353ee517f6 100644
--- a/security/integrity/ima/ima_appraise.c
+++ b/security/integrity/ima/ima_appraise.c
@@ -15,6 +15,7 @@
 #include <linux/magic.h>
 #include <linux/ima.h>
 #include <linux/evm.h>
+#include <crypto/hash_info.h>
 #include "ima.h"
@@ -43,19 +44,31 @@ int ima_must_appraise(struct inode *inode, int mask, enum ima_hooks func)
 }
 static int ima_fix_xattr(struct dentry *dentry,
-                          struct integrity_iint_cache *iint)
+                         struct integrity_iint_cache *iint)
 {
-        iint->ima_xattr.type = IMA_XATTR_DIGEST;
+        int rc, offset;
-        return __vfs_setxattr_noperm(dentry, XATTR_NAME_IMA,
+        u8 algo = iint->ima_hash->algo;
-                                     (u8 *)&iint->ima_xattr,
-                                      sizeof(iint->ima_xattr), 0);
+        if (algo <= HASH_ALGO_SHA1) {
+                offset = 1;
+                iint->ima_hash->xattr.sha1.type = IMA_XATTR_DIGEST;
+        } else {
+                offset = 0;
+                iint->ima_hash->xattr.ng.type = IMA_XATTR_DIGEST_NG;
+                iint->ima_hash->xattr.ng.algo = algo;
+        }
+        rc = __vfs_setxattr_noperm(dentry, XATTR_NAME_IMA,
+                                   &iint->ima_hash->xattr.data[offset],
+                                   (sizeof(iint->ima_hash->xattr) - offset) +
+                                   iint->ima_hash->length, 0);
+        return rc;
 }
 /* Return specific func appraised cached result */
 enum integrity_status ima_get_cache_status(struct integrity_iint_cache *iint,
                                           int func)
 {
-        switch(func) {
+        switch (func) {
        case MMAP_CHECK:
                return iint->ima_mmap_status;
        case BPRM_CHECK:
@@ -71,7 +84,7 @@ enum integrity_status ima_get_cache_status(struct integrity_iint_cache *iint,
 static void ima_set_cache_status(struct integrity_iint_cache *iint,
                                 int func, enum integrity_status status)
 {
-        switch(func) {
+        switch (func) {
        case MMAP_CHECK:
                iint->ima_mmap_status = status;
                break;
@@ -90,7 +103,7 @@ static void ima_set_cache_status(struct integrity_iint_cache *iint,
 static void ima_cache_flags(struct integrity_iint_cache *iint, int func)
 {
-        switch(func) {
+        switch (func) {
        case MMAP_CHECK:
                iint->flags |= (IMA_MMAP_APPRAISED | IMA_APPRAISED);
                break;
@@ -107,6 +120,50 @@ static void ima_cache_flags(struct integrity_iint_cache *iint, int func)
        }
 }
+void ima_get_hash_algo(struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                       struct ima_digest_data *hash)
+{
+        struct signature_v2_hdr *sig;
+        if (!xattr_value || xattr_len < 2)
+                return;
+        switch (xattr_value->type) {
+        case EVM_IMA_XATTR_DIGSIG:
+                sig = (typeof(sig))xattr_value;
+                if (sig->version != 2 || xattr_len <= sizeof(*sig))
+                        return;
+                hash->algo = sig->hash_algo;
+                break;
+        case IMA_XATTR_DIGEST_NG:
+                hash->algo = xattr_value->digest[0];
+                break;
+        case IMA_XATTR_DIGEST:
+                /* this is for backward compatibility */
+                if (xattr_len == 21) {
+                        unsigned int zero = 0;
+                        if (!memcmp(&xattr_value->digest[16], &zero, 4))
+                                hash->algo = HASH_ALGO_MD5;
+                        else
+                                hash->algo = HASH_ALGO_SHA1;
+                } else if (xattr_len == 17)
+                        hash->algo = HASH_ALGO_MD5;
+                break;
+        }
+}
+int ima_read_xattr(struct dentry *dentry,
+                   struct evm_ima_xattr_data **xattr_value)
+{
+        struct inode *inode = dentry->d_inode;
+        if (!inode->i_op->getxattr)
+                return 0;
+        return vfs_getxattr_alloc(dentry, XATTR_NAME_IMA, (char **)xattr_value,
+                                  0, GFP_NOFS);
+}
 /*
 * ima_appraise_measurement - appraise file measurement
 *
@@ -116,23 +173,22 @@ static void ima_cache_flags(struct integrity_iint_cache *iint, int func)
 * Return 0 on success, error code otherwise
 */
 int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
-                             struct file *file, const unsigned char *filename)
+                             struct file *file, const unsigned char *filename,
+                             struct evm_ima_xattr_data *xattr_value,
+                             int xattr_len)
 {
        struct dentry *dentry = file->f_dentry;
        struct inode *inode = dentry->d_inode;
-        struct evm_ima_xattr_data *xattr_value = NULL;
        enum integrity_status status = INTEGRITY_UNKNOWN;
        const char *op = "appraise_data";
        char *cause = "unknown";
-        int rc;
+        int rc = xattr_len, hash_start = 0;
        if (!ima_appraise)
                return 0;
        if (!inode->i_op->getxattr)
                return INTEGRITY_UNKNOWN;
-        rc = vfs_getxattr_alloc(dentry, XATTR_NAME_IMA, (char **)&xattr_value,
-                                0, GFP_NOFS);
        if (rc <= 0) {
                if (rc && rc != -ENODATA)
                        goto out;
@@ -153,14 +209,25 @@ int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
                goto out;
        }
        switch (xattr_value->type) {
+        case IMA_XATTR_DIGEST_NG:
+                /* first byte contains algorithm id */
+                hash_start = 1;
        case IMA_XATTR_DIGEST:
                if (iint->flags & IMA_DIGSIG_REQUIRED) {
                        cause = "IMA signature required";
                        status = INTEGRITY_FAIL;
                        break;
                }
-                rc = memcmp(xattr_value->digest, iint->ima_xattr.digest,
+                if (xattr_len - sizeof(xattr_value->type) - hash_start >=
-                            IMA_DIGEST_SIZE);
+                                iint->ima_hash->length)
+                        /* xattr length may be longer. md5 hash in previous
+                           version occupied 20 bytes in xattr, instead of 16
+                         */
+                        rc = memcmp(&xattr_value->digest[hash_start],
+                                    iint->ima_hash->digest,
+                                    iint->ima_hash->length);
+                else
+                        rc = -EINVAL;
                if (rc) {
                        cause = "invalid-hash";
                        status = INTEGRITY_FAIL;
@@ -171,9 +238,9 @@ int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
        case EVM_IMA_XATTR_DIGSIG:
                iint->flags |= IMA_DIGSIG;
                rc = integrity_digsig_verify(INTEGRITY_KEYRING_IMA,
-                                             xattr_value->digest, rc - 1,
+                                             (const char *)xattr_value, rc,
-                                             iint->ima_xattr.digest,
+                                             iint->ima_hash->digest,
-                                             IMA_DIGEST_SIZE);
+                                             iint->ima_hash->length);
                if (rc == -EOPNOTSUPP) {
                        status = INTEGRITY_UNKNOWN;
                } else if (rc) {
@@ -203,7 +270,6 @@ out:
                ima_cache_flags(iint, func);
        }
        ima_set_cache_status(iint, func, status);
-        kfree(xattr_value);
        return status;
 }
@@ -219,7 +285,7 @@ void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file)
        if (iint->flags & IMA_DIGSIG)
                return;
-        rc = ima_collect_measurement(iint, file);
+        rc = ima_collect_measurement(iint, file, NULL, NULL);
        if (rc < 0)
                return;
@@ -315,3 +381,14 @@ int ima_inode_removexattr(struct dentry *dentry, const char *xattr_name)
        }
        return result;
 }
+#ifdef CONFIG_IMA_TRUSTED_KEYRING
+static int __init init_ima_keyring(void)
+{
+        int ret;
+        ret = integrity_init_keyring(INTEGRITY_KEYRING_IMA);
+        return 0;
+}
+late_initcall(init_ima_keyring);
+#endif
diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c
index a02e0791cf15..676e0292dfec 100644
--- a/security/integrity/ima/ima_crypto.c
+++ b/security/integrity/ima/ima_crypto.c
@@ -20,6 +20,7 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <crypto/hash.h>
+#include <crypto/hash_info.h>
 #include "ima.h"
 static struct crypto_shash *ima_shash_tfm;
@@ -28,31 +29,58 @@ int ima_init_crypto(void)
 {
        long rc;
-        ima_shash_tfm = crypto_alloc_shash(ima_hash, 0, 0);
+        ima_shash_tfm = crypto_alloc_shash(hash_algo_name[ima_hash_algo], 0, 0);
        if (IS_ERR(ima_shash_tfm)) {
                rc = PTR_ERR(ima_shash_tfm);
-                pr_err("Can not allocate %s (reason: %ld)\n", ima_hash, rc);
+                pr_err("Can not allocate %s (reason: %ld)\n",
+                       hash_algo_name[ima_hash_algo], rc);
                return rc;
        }
        return 0;
 }
+static struct crypto_shash *ima_alloc_tfm(enum hash_algo algo)
+{
+        struct crypto_shash *tfm = ima_shash_tfm;
+        int rc;
+        if (algo != ima_hash_algo && algo < HASH_ALGO__LAST) {
+                tfm = crypto_alloc_shash(hash_algo_name[algo], 0, 0);
+                if (IS_ERR(tfm)) {
+                        rc = PTR_ERR(tfm);
+                        pr_err("Can not allocate %s (reason: %d)\n",
+                               hash_algo_name[algo], rc);
+                }
+        }
+        return tfm;
+}
+static void ima_free_tfm(struct crypto_shash *tfm)
+{
+        if (tfm != ima_shash_tfm)
+                crypto_free_shash(tfm);
+}
 /*
 * Calculate the MD5/SHA1 file digest
 */
-int ima_calc_file_hash(struct file *file, char *digest)
+static int ima_calc_file_hash_tfm(struct file *file,
+                                  struct ima_digest_data *hash,
+                                  struct crypto_shash *tfm)
 {
        loff_t i_size, offset = 0;
        char *rbuf;
        int rc, read = 0;
        struct {
                struct shash_desc shash;
-                char ctx[crypto_shash_descsize(ima_shash_tfm)];
+                char ctx[crypto_shash_descsize(tfm)];
        } desc;
-        desc.shash.tfm = ima_shash_tfm;
+        desc.shash.tfm = tfm;
        desc.shash.flags = 0;
+        hash->length = crypto_shash_digestsize(tfm);
        rc = crypto_shash_init(&desc.shash);
        if (rc != 0)
                return rc;
@@ -85,27 +113,83 @@ int ima_calc_file_hash(struct file *file, char *digest)
        }
        kfree(rbuf);
        if (!rc)
-                rc = crypto_shash_final(&desc.shash, digest);
+                rc = crypto_shash_final(&desc.shash, hash->digest);
        if (read)
                file->f_mode &= ~FMODE_READ;
 out:
        return rc;
 }
+int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash)
+{
+        struct crypto_shash *tfm;
+        int rc;
+        tfm = ima_alloc_tfm(hash->algo);
+        if (IS_ERR(tfm))
+                return PTR_ERR(tfm);
+        rc = ima_calc_file_hash_tfm(file, hash, tfm);
+        ima_free_tfm(tfm);
+        return rc;
+}
 /*
- * Calculate the hash of a given buffer
+ * Calculate the hash of template data
 */
-int ima_calc_buffer_hash(const void *data, int len, char *digest)
+static int ima_calc_field_array_hash_tfm(struct ima_field_data *field_data,
+                                         int num_fields,
+                                         struct ima_digest_data *hash,
+                                         struct crypto_shash *tfm)
 {
        struct {
                struct shash_desc shash;
-                char ctx[crypto_shash_descsize(ima_shash_tfm)];
+                char ctx[crypto_shash_descsize(tfm)];
        } desc;
+        int rc, i;
-        desc.shash.tfm = ima_shash_tfm;
+        desc.shash.tfm = tfm;
        desc.shash.flags = 0;
-        return crypto_shash_digest(&desc.shash, data, len, digest);
+        hash->length = crypto_shash_digestsize(tfm);
+        rc = crypto_shash_init(&desc.shash);
+        if (rc != 0)
+                return rc;
+        for (i = 0; i < num_fields; i++) {
+                rc = crypto_shash_update(&desc.shash,
+                                         (const u8 *) &field_data[i].len,
+                                         sizeof(field_data[i].len));
+                rc = crypto_shash_update(&desc.shash, field_data[i].data,
+                                         field_data[i].len);
+                if (rc)
+                        break;
+        }
+        if (!rc)
+                rc = crypto_shash_final(&desc.shash, hash->digest);
+        return rc;
+}
+int ima_calc_field_array_hash(struct ima_field_data *field_data, int num_fields,
+                              struct ima_digest_data *hash)
+{
+        struct crypto_shash *tfm;
+        int rc;
+        tfm = ima_alloc_tfm(hash->algo);
+        if (IS_ERR(tfm))
+                return PTR_ERR(tfm);
+        rc = ima_calc_field_array_hash_tfm(field_data, num_fields, hash, tfm);
+        ima_free_tfm(tfm);
+        return rc;
 }
 static void __init ima_pcrread(int idx, u8 *pcr)
@@ -120,16 +204,17 @@ static void __init ima_pcrread(int idx, u8 *pcr)
 /*
 * Calculate the boot aggregate hash
 */
-int __init ima_calc_boot_aggregate(char *digest)
+static int __init ima_calc_boot_aggregate_tfm(char *digest,
+                                              struct crypto_shash *tfm)
 {
-        u8 pcr_i[IMA_DIGEST_SIZE];
+        u8 pcr_i[TPM_DIGEST_SIZE];
        int rc, i;
        struct {
                struct shash_desc shash;
-                char ctx[crypto_shash_descsize(ima_shash_tfm)];
+                char ctx[crypto_shash_descsize(tfm)];
        } desc;
-        desc.shash.tfm = ima_shash_tfm;
+        desc.shash.tfm = tfm;
        desc.shash.flags = 0;
        rc = crypto_shash_init(&desc.shash);
@@ -140,9 +225,26 @@ int __init ima_calc_boot_aggregate(char *digest)
        for (i = TPM_PCR0; i < TPM_PCR8; i++) {
                ima_pcrread(i, pcr_i);
                /* now accumulate with current aggregate */
-                rc = crypto_shash_update(&desc.shash, pcr_i, IMA_DIGEST_SIZE);
+                rc = crypto_shash_update(&desc.shash, pcr_i, TPM_DIGEST_SIZE);
        }
        if (!rc)
                crypto_shash_final(&desc.shash, digest);
        return rc;
 }
+int __init ima_calc_boot_aggregate(struct ima_digest_data *hash)
+{
+        struct crypto_shash *tfm;
+        int rc;
+        tfm = ima_alloc_tfm(hash->algo);
+        if (IS_ERR(tfm))
+                return PTR_ERR(tfm);
+        hash->length = crypto_shash_digestsize(tfm);
+        rc = ima_calc_boot_aggregate_tfm(hash->digest, tfm);
+        ima_free_tfm(tfm);
+        return rc;
+}
diff --git a/security/integrity/ima/ima_fs.c b/security/integrity/ima/ima_fs.c
index 38477c9c3415..d47a7c86a21d 100644
--- a/security/integrity/ima/ima_fs.c
+++ b/security/integrity/ima/ima_fs.c
@@ -88,8 +88,7 @@ static void *ima_measurements_next(struct seq_file *m, void *v, loff_t *pos)
         * against concurrent list-extension
         */
        rcu_read_lock();
-        qe = list_entry_rcu(qe->later.next,
+        qe = list_entry_rcu(qe->later.next, struct ima_queue_entry, later);
-                            struct ima_queue_entry, later);
        rcu_read_unlock();
        (*pos)++;
@@ -100,7 +99,7 @@ static void ima_measurements_stop(struct seq_file *m, void *v)
 {
 }
-static void ima_putc(struct seq_file *m, void *data, int datalen)
+void ima_putc(struct seq_file *m, void *data, int datalen)
 {
        while (datalen--)
                seq_putc(m, *(char *)data++);
@@ -111,6 +110,7 @@ static void ima_putc(struct seq_file *m, void *data, int datalen)
 *       char[20]=template digest
 *       32bit-le=template name size
 *       char[n]=template name
+ *       [eventdata length]
 *       eventdata[n]=template specific data
 */
 static int ima_measurements_show(struct seq_file *m, void *v)
@@ -120,6 +120,7 @@ static int ima_measurements_show(struct seq_file *m, void *v)
        struct ima_template_entry *e;
        int namelen;
        u32 pcr = CONFIG_IMA_MEASURE_PCR_IDX;
+        int i;
        /* get entry */
        e = qe->entry;
@@ -134,18 +135,25 @@ static int ima_measurements_show(struct seq_file *m, void *v)
        ima_putc(m, &pcr, sizeof pcr);
        /* 2nd: template digest */
-        ima_putc(m, e->digest, IMA_DIGEST_SIZE);
+        ima_putc(m, e->digest, TPM_DIGEST_SIZE);
        /* 3rd: template name size */
-        namelen = strlen(e->template_name);
+        namelen = strlen(e->template_desc->name);
        ima_putc(m, &namelen, sizeof namelen);
        /* 4th:  template name */
-        ima_putc(m, (void *)e->template_name, namelen);
+        ima_putc(m, e->template_desc->name, namelen);
+        /* 5th:  template length (except for 'ima' template) */
+        if (strcmp(e->template_desc->name, IMA_TEMPLATE_IMA_NAME) != 0)
+                ima_putc(m, &e->template_data_len,
+                         sizeof(e->template_data_len));
-        /* 5th:  template specific data */
+        /* 6th:  template specific data */
-        ima_template_show(m, (struct ima_template_data *)&e->template,
+        for (i = 0; i < e->template_desc->num_fields; i++) {
-                          IMA_SHOW_BINARY);
+                e->template_desc->fields[i]->field_show(m, IMA_SHOW_BINARY,
+                                                        &e->template_data[i]);
+        }
        return 0;
 }
@@ -168,41 +176,21 @@ static const struct file_operations ima_measurements_ops = {
        .release = seq_release,
 };
-static void ima_print_digest(struct seq_file *m, u8 *digest)
+void ima_print_digest(struct seq_file *m, u8 *digest, int size)
 {
        int i;
-        for (i = 0; i < IMA_DIGEST_SIZE; i++)
+        for (i = 0; i < size; i++)
                seq_printf(m, "%02x", *(digest + i));
 }
-void ima_template_show(struct seq_file *m, void *e, enum ima_show_type show)
-{
-        struct ima_template_data *entry = e;
-        int namelen;
-        switch (show) {
-        case IMA_SHOW_ASCII:
-                ima_print_digest(m, entry->digest);
-                seq_printf(m, " %s\n", entry->file_name);
-                break;
-        case IMA_SHOW_BINARY:
-                ima_putc(m, entry->digest, IMA_DIGEST_SIZE);
-                namelen = strlen(entry->file_name);
-                ima_putc(m, &namelen, sizeof namelen);
-                ima_putc(m, entry->file_name, namelen);
-        default:
-                break;
-        }
-}
 /* print in ascii */
 static int ima_ascii_measurements_show(struct seq_file *m, void *v)
 {
        /* the list never shrinks, so we don't need a lock here */
        struct ima_queue_entry *qe = v;
        struct ima_template_entry *e;
+        int i;
        /* get entry */
        e = qe->entry;
@@ -213,14 +201,21 @@ static int ima_ascii_measurements_show(struct seq_file *m, void *v)
        seq_printf(m, "%2d ", CONFIG_IMA_MEASURE_PCR_IDX);
        /* 2nd: SHA1 template hash */
-        ima_print_digest(m, e->digest);
+        ima_print_digest(m, e->digest, TPM_DIGEST_SIZE);
        /* 3th:  template name */
-        seq_printf(m, " %s ", e->template_name);
+        seq_printf(m, " %s", e->template_desc->name);
        /* 4th:  template specific data */
-        ima_template_show(m, (struct ima_template_data *)&e->template,
+        for (i = 0; i < e->template_desc->num_fields; i++) {
-                          IMA_SHOW_ASCII);
+                seq_puts(m, " ");
+                if (e->template_data[i].len == 0)
+                        continue;
+                e->template_desc->fields[i]->field_show(m, IMA_SHOW_ASCII,
+                                                        &e->template_data[i]);
+        }
+        seq_puts(m, "\n");
        return 0;
 }
diff --git a/security/integrity/ima/ima_init.c b/security/integrity/ima/ima_init.c
index 162ea723db3d..15f34bd40abe 100644
--- a/security/integrity/ima/ima_init.c
+++ b/security/integrity/ima/ima_init.c
@@ -18,6 +18,7 @@
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 #include <linux/err.h>
+#include <crypto/hash_info.h>
 #include "ima.h"
 /* name for boot aggregate entry */
@@ -42,28 +43,38 @@ int ima_used_chip;
 static void __init ima_add_boot_aggregate(void)
 {
        struct ima_template_entry *entry;
+        struct integrity_iint_cache tmp_iint, *iint = &tmp_iint;
        const char *op = "add_boot_aggregate";
        const char *audit_cause = "ENOMEM";
        int result = -ENOMEM;
-        int violation = 1;
+        int violation = 0;
+        struct {
+                struct ima_digest_data hdr;
+                char digest[TPM_DIGEST_SIZE];
+        } hash;
-        entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+        memset(iint, 0, sizeof(*iint));
-        if (!entry)
+        memset(&hash, 0, sizeof(hash));
-                goto err_out;
+        iint->ima_hash = &hash.hdr;
+        iint->ima_hash->algo = HASH_ALGO_SHA1;
+        iint->ima_hash->length = SHA1_DIGEST_SIZE;
-        memset(&entry->template, 0, sizeof(entry->template));
-        strncpy(entry->template.file_name, boot_aggregate_name,
-                IMA_EVENT_NAME_LEN_MAX);
        if (ima_used_chip) {
-                violation = 0;
+                result = ima_calc_boot_aggregate(&hash.hdr);
-                result = ima_calc_boot_aggregate(entry->template.digest);
                if (result < 0) {
                        audit_cause = "hashing_error";
                        kfree(entry);
                        goto err_out;
                }
        }
-        result = ima_store_template(entry, violation, NULL);
+        result = ima_alloc_init_template(iint, NULL, boot_aggregate_name,
+                                         NULL, 0, &entry);
+        if (result < 0)
+                return;
+        result = ima_store_template(entry, violation, NULL,
+                                    boot_aggregate_name);
        if (result < 0)
                kfree(entry);
        return;
@@ -74,7 +85,7 @@ err_out:
 int __init ima_init(void)
 {
-        u8 pcr_i[IMA_DIGEST_SIZE];
+        u8 pcr_i[TPM_DIGEST_SIZE];
        int rc;
        ima_used_chip = 0;
@@ -88,6 +99,10 @@ int __init ima_init(void)
        rc = ima_init_crypto();
        if (rc)
                return rc;
+        rc = ima_init_template();
+        if (rc != 0)
+                return rc;
        ima_add_boot_aggregate();       /* boot aggregate must be first entry */
        ima_init_policy();
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index e9508d5bbfcf..149ee1119f87 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -24,6 +24,7 @@
 #include <linux/slab.h>
 #include <linux/xattr.h>
 #include <linux/ima.h>
+#include <crypto/hash_info.h>
 #include "ima.h"
@@ -35,11 +36,33 @@ int ima_appraise = IMA_APPRAISE_ENFORCE;
 int ima_appraise;
 #endif
-char *ima_hash = "sha1";
+int ima_hash_algo = HASH_ALGO_SHA1;
+static int hash_setup_done;
 static int __init hash_setup(char *str)
 {
-        if (strncmp(str, "md5", 3) == 0)
+        struct ima_template_desc *template_desc = ima_template_desc_current();
-                ima_hash = "md5";
+        int i;
+        if (hash_setup_done)
+                return 1;
+        if (strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) == 0) {
+                if (strncmp(str, "sha1", 4) == 0)
+                        ima_hash_algo = HASH_ALGO_SHA1;
+                else if (strncmp(str, "md5", 3) == 0)
+                        ima_hash_algo = HASH_ALGO_MD5;
+                goto out;
+        }
+        for (i = 0; i < HASH_ALGO__LAST; i++) {
+                if (strcmp(str, hash_algo_name[i]) == 0) {
+                        ima_hash_algo = i;
+                        break;
+                }
+        }
+out:
+        hash_setup_done = 1;
        return 1;
 }
 __setup("ima_hash=", hash_setup);
@@ -92,10 +115,9 @@ out:
                pathname = dentry->d_name.name;
        if (send_tomtou)
-                ima_add_violation(inode, pathname,
+                ima_add_violation(file, pathname, "invalid_pcr", "ToMToU");
-                                  "invalid_pcr", "ToMToU");
        if (send_writers)
-                ima_add_violation(inode, pathname,
+                ima_add_violation(file, pathname,
                                  "invalid_pcr", "open_writers");
        kfree(pathbuf);
 }
@@ -144,9 +166,12 @@ static int process_measurement(struct file *file, const char *filename,
 {
        struct inode *inode = file_inode(file);
        struct integrity_iint_cache *iint;
+        struct ima_template_desc *template_desc = ima_template_desc_current();
        char *pathbuf = NULL;
        const char *pathname = NULL;
        int rc = -ENOMEM, action, must_appraise, _func;
+        struct evm_ima_xattr_data *xattr_value = NULL, **xattr_ptr = NULL;
+        int xattr_len = 0;
        if (!ima_initialized || !S_ISREG(inode->i_mode))
                return 0;
@@ -185,7 +210,13 @@ static int process_measurement(struct file *file, const char *filename,
                goto out_digsig;
        }
-        rc = ima_collect_measurement(iint, file);
+        if (strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) == 0) {
+                if (action & IMA_APPRAISE_SUBMASK)
+                        xattr_ptr = &xattr_value;
+        } else
+                xattr_ptr = &xattr_value;
+        rc = ima_collect_measurement(iint, file, xattr_ptr, &xattr_len);
        if (rc != 0)
                goto out_digsig;
@@ -194,9 +225,11 @@ static int process_measurement(struct file *file, const char *filename,
                pathname = (const char *)file->f_dentry->d_name.name;
        if (action & IMA_MEASURE)
-                ima_store_measurement(iint, file, pathname);
+                ima_store_measurement(iint, file, pathname,
+                                      xattr_value, xattr_len);
        if (action & IMA_APPRAISE_SUBMASK)
-                rc = ima_appraise_measurement(_func, iint, file, pathname);
+                rc = ima_appraise_measurement(_func, iint, file, pathname,
+                                              xattr_value, xattr_len);
        if (action & IMA_AUDIT)
                ima_audit_measurement(iint, pathname);
        kfree(pathbuf);
@@ -205,6 +238,7 @@ out_digsig:
                rc = -EACCES;
 out:
        mutex_unlock(&inode->i_mutex);
+        kfree(xattr_value);
        if ((rc && must_appraise) && (ima_appraise & IMA_APPRAISE_ENFORCE))
                return -EACCES;
        return 0;
@@ -244,9 +278,9 @@ int ima_file_mmap(struct file *file, unsigned long prot)
 int ima_bprm_check(struct linux_binprm *bprm)
 {
        return process_measurement(bprm->file,
-                                 (strcmp(bprm->filename, bprm->interp) == 0) ?
+                                   (strcmp(bprm->filename, bprm->interp) == 0) ?
-                                 bprm->filename : bprm->interp,
+                                   bprm->filename : bprm->interp,
-                                 MAY_EXEC, BPRM_CHECK);
+                                   MAY_EXEC, BPRM_CHECK);
 }
 /**
@@ -263,8 +297,8 @@ int ima_file_check(struct file *file, int mask)
 {
        ima_rdwr_violation_check(file);
        return process_measurement(file, NULL,
-                                 mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
+                                   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
-                                 FILE_CHECK);
+                                   FILE_CHECK);
 }
 EXPORT_SYMBOL_GPL(ima_file_check);
@@ -294,6 +328,7 @@ static int __init init_ima(void)
 {
        int error;
+        hash_setup(CONFIG_IMA_DEFAULT_HASH);
        error = ima_init();
        if (!error)
                ima_initialized = 1;
diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
index 399433ad614e..a9c3d3cd1990 100644
--- a/security/integrity/ima/ima_policy.c
+++ b/security/integrity/ima/ima_policy.c
@@ -73,7 +73,6 @@ static struct ima_rule_entry default_rules[] = {
        {.action = DONT_MEASURE,.fsmagic = SYSFS_MAGIC,.flags = IMA_FSMAGIC},
        {.action = DONT_MEASURE,.fsmagic = DEBUGFS_MAGIC,.flags = IMA_FSMAGIC},
        {.action = DONT_MEASURE,.fsmagic = TMPFS_MAGIC,.flags = IMA_FSMAGIC},
-        {.action = DONT_MEASURE,.fsmagic = RAMFS_MAGIC,.flags = IMA_FSMAGIC},
        {.action = DONT_MEASURE,.fsmagic = DEVPTS_SUPER_MAGIC,.flags = IMA_FSMAGIC},
        {.action = DONT_MEASURE,.fsmagic = BINFMTFS_MAGIC,.flags = IMA_FSMAGIC},
        {.action = DONT_MEASURE,.fsmagic = SECURITYFS_MAGIC,.flags = IMA_FSMAGIC},
diff --git a/security/integrity/ima/ima_queue.c b/security/integrity/ima/ima_queue.c
index ff63fe00c195..d85e99761f4f 100644
--- a/security/integrity/ima/ima_queue.c
+++ b/security/integrity/ima/ima_queue.c
@@ -50,7 +50,7 @@ static struct ima_queue_entry *ima_lookup_digest_entry(u8 *digest_value)
        key = ima_hash_key(digest_value);
        rcu_read_lock();
        hlist_for_each_entry_rcu(qe, &ima_htable.queue[key], hnext) {
-                rc = memcmp(qe->entry->digest, digest_value, IMA_DIGEST_SIZE);
+                rc = memcmp(qe->entry->digest, digest_value, TPM_DIGEST_SIZE);
                if (rc == 0) {
                        ret = qe;
                        break;
@@ -104,9 +104,10 @@ static int ima_pcr_extend(const u8 *hash)
 * and extend the pcr.
 */
 int ima_add_template_entry(struct ima_template_entry *entry, int violation,
-                           const char *op, struct inode *inode)
+                           const char *op, struct inode *inode,
+                           const unsigned char *filename)
 {
-        u8 digest[IMA_DIGEST_SIZE];
+        u8 digest[TPM_DIGEST_SIZE];
        const char *audit_cause = "hash_added";
        char tpm_audit_cause[AUDIT_CAUSE_LEN_MAX];
        int audit_info = 1;
@@ -141,8 +142,7 @@ int ima_add_template_entry(struct ima_template_entry *entry, int violation,
        }
 out:
        mutex_unlock(&ima_extend_list_mutex);
-        integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
+        integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
-                            entry->template.file_name,
                            op, audit_cause, result, audit_info);
        return result;
 }
diff --git a/security/integrity/ima/ima_template.c b/security/integrity/ima/ima_template.c
new file mode 100644
index 000000000000..4e5da990630b
--- /dev/null
+++ b/security/integrity/ima/ima_template.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2013 Politecnico di Torino, Italy
+ *                    TORSEC group -- http://security.polito.it
+ *
+ * Author: Roberto Sassu <roberto.sassu@polito.it>
+ *
+ * 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.
+ *
+ * File: ima_template.c
+ *      Helpers to manage template descriptors.
+ */
+#include <crypto/hash_info.h>
+#include "ima.h"
+#include "ima_template_lib.h"
+static struct ima_template_desc defined_templates[] = {
+        {.name = IMA_TEMPLATE_IMA_NAME, .fmt = IMA_TEMPLATE_IMA_FMT},
+        {.name = "ima-ng",.fmt = "d-ng|n-ng"},
+        {.name = "ima-sig",.fmt = "d-ng|n-ng|sig"},
+};
+static struct ima_template_field supported_fields[] = {
+        {.field_id = "d",.field_init = ima_eventdigest_init,
+         .field_show = ima_show_template_digest},
+        {.field_id = "n",.field_init = ima_eventname_init,
+         .field_show = ima_show_template_string},
+        {.field_id = "d-ng",.field_init = ima_eventdigest_ng_init,
+         .field_show = ima_show_template_digest_ng},
+        {.field_id = "n-ng",.field_init = ima_eventname_ng_init,
+         .field_show = ima_show_template_string},
+        {.field_id = "sig",.field_init = ima_eventsig_init,
+         .field_show = ima_show_template_sig},
+};
+static struct ima_template_desc *ima_template;
+static struct ima_template_desc *lookup_template_desc(const char *name);
+static int __init ima_template_setup(char *str)
+{
+        struct ima_template_desc *template_desc;
+        int template_len = strlen(str);
+        /*
+         * Verify that a template with the supplied name exists.
+         * If not, use CONFIG_IMA_DEFAULT_TEMPLATE.
+         */
+        template_desc = lookup_template_desc(str);
+        if (!template_desc)
+                return 1;
+        /*
+         * Verify whether the current hash algorithm is supported
+         * by the 'ima' template.
+         */
+        if (template_len == 3 && strcmp(str, IMA_TEMPLATE_IMA_NAME) == 0 &&
+            ima_hash_algo != HASH_ALGO_SHA1 && ima_hash_algo != HASH_ALGO_MD5) {
+                pr_err("IMA: template does not support hash alg\n");
+                return 1;
+        }
+        ima_template = template_desc;
+        return 1;
+}
+__setup("ima_template=", ima_template_setup);
+static struct ima_template_desc *lookup_template_desc(const char *name)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(defined_templates); i++) {
+                if (strcmp(defined_templates[i].name, name) == 0)
+                        return defined_templates + i;
+        }
+        return NULL;
+}
+static struct ima_template_field *lookup_template_field(const char *field_id)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(supported_fields); i++)
+                if (strncmp(supported_fields[i].field_id, field_id,
+                            IMA_TEMPLATE_FIELD_ID_MAX_LEN) == 0)
+                        return &supported_fields[i];
+        return NULL;
+}
+static int template_fmt_size(char *template_fmt)
+{
+        char c;
+        int template_fmt_len = strlen(template_fmt);
+        int i = 0, j = 0;
+        while (i < template_fmt_len) {
+                c = template_fmt[i];
+                if (c == '|')
+                        j++;
+                i++;
+        }
+        return j + 1;
+}
+static int template_desc_init_fields(char *template_fmt,
+                                     struct ima_template_field ***fields,
+                                     int *num_fields)
+{
+        char *c, *template_fmt_ptr = template_fmt;
+        int template_num_fields = template_fmt_size(template_fmt);
+        int i, result = 0;
+        if (template_num_fields > IMA_TEMPLATE_NUM_FIELDS_MAX)
+                return -EINVAL;
+        *fields = kzalloc(template_num_fields * sizeof(*fields), GFP_KERNEL);
+        if (*fields == NULL) {
+                result = -ENOMEM;
+                goto out;
+        }
+        for (i = 0; (c = strsep(&template_fmt_ptr, "|")) != NULL &&
+             i < template_num_fields; i++) {
+                struct ima_template_field *f = lookup_template_field(c);
+                if (!f) {
+                        result = -ENOENT;
+                        goto out;
+                }
+                (*fields)[i] = f;
+        }
+        *num_fields = i;
+        return 0;
+out:
+        kfree(*fields);
+        *fields = NULL;
+        return result;
+}
+static int init_defined_templates(void)
+{
+        int i = 0;
+        int result = 0;
+        /* Init defined templates. */
+        for (i = 0; i < ARRAY_SIZE(defined_templates); i++) {
+                struct ima_template_desc *template = &defined_templates[i];
+                result = template_desc_init_fields(template->fmt,
+                                                   &(template->fields),
+                                                   &(template->num_fields));
+                if (result < 0)
+                        return result;
+        }
+        return result;
+}
+struct ima_template_desc *ima_template_desc_current(void)
+{
+        if (!ima_template)
+                ima_template =
+                    lookup_template_desc(CONFIG_IMA_DEFAULT_TEMPLATE);
+        return ima_template;
+}
+int ima_init_template(void)
+{
+        int result;
+        result = init_defined_templates();
+        if (result < 0)
+                return result;
+        return 0;
+}
diff --git a/security/integrity/ima/ima_template_lib.c b/security/integrity/ima/ima_template_lib.c
new file mode 100644
index 000000000000..6d66ad6ed265
--- /dev/null
+++ b/security/integrity/ima/ima_template_lib.c
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2013 Politecnico di Torino, Italy
+ *                    TORSEC group -- http://security.polito.it
+ *
+ * Author: Roberto Sassu <roberto.sassu@polito.it>
+ *
+ * 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.
+ *
+ * File: ima_template_lib.c
+ *      Library of supported template fields.
+ */
+#include <crypto/hash_info.h>
+#include "ima_template_lib.h"
+static bool ima_template_hash_algo_allowed(u8 algo)
+{
+        if (algo == HASH_ALGO_SHA1 || algo == HASH_ALGO_MD5)
+                return true;
+        return false;
+}
+enum data_formats {
+        DATA_FMT_DIGEST = 0,
+        DATA_FMT_DIGEST_WITH_ALGO,
+        DATA_FMT_EVENT_NAME,
+        DATA_FMT_STRING,
+        DATA_FMT_HEX
+};
+static int ima_write_template_field_data(const void *data, const u32 datalen,
+                                         enum data_formats datafmt,
+                                         struct ima_field_data *field_data)
+{
+        u8 *buf, *buf_ptr;
+        u32 buflen;
+        switch (datafmt) {
+        case DATA_FMT_EVENT_NAME:
+                buflen = IMA_EVENT_NAME_LEN_MAX + 1;
+                break;
+        case DATA_FMT_STRING:
+                buflen = datalen + 1;
+                break;
+        default:
+                buflen = datalen;
+        }
+        buf = kzalloc(buflen, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        memcpy(buf, data, datalen);
+        /*
+         * Replace all space characters with underscore for event names and
+         * strings. This avoid that, during the parsing of a measurements list,
+         * filenames with spaces or that end with the suffix ' (deleted)' are
+         * split into multiple template fields (the space is the delimitator
+         * character for measurements lists in ASCII format).
+         */
+        if (datafmt == DATA_FMT_EVENT_NAME || datafmt == DATA_FMT_STRING) {
+                for (buf_ptr = buf; buf_ptr - buf < datalen; buf_ptr++)
+                        if (*buf_ptr == ' ')
+                                *buf_ptr = '_';
+        }
+        field_data->data = buf;
+        field_data->len = buflen;
+        return 0;
+}
+static void ima_show_template_data_ascii(struct seq_file *m,
+                                         enum ima_show_type show,
+                                         enum data_formats datafmt,
+                                         struct ima_field_data *field_data)
+{
+        u8 *buf_ptr = field_data->data, buflen = field_data->len;
+        switch (datafmt) {
+        case DATA_FMT_DIGEST_WITH_ALGO:
+                buf_ptr = strnchr(field_data->data, buflen, ':');
+                if (buf_ptr != field_data->data)
+                        seq_printf(m, "%s", field_data->data);
+                /* skip ':' and '\0' */
+                buf_ptr += 2;
+                buflen -= buf_ptr - field_data->data;
+        case DATA_FMT_DIGEST:
+        case DATA_FMT_HEX:
+                if (!buflen)
+                        break;
+                ima_print_digest(m, buf_ptr, buflen);
+                break;
+        case DATA_FMT_STRING:
+                seq_printf(m, "%s", buf_ptr);
+                break;
+        default:
+                break;
+        }
+}
+static void ima_show_template_data_binary(struct seq_file *m,
+                                          enum ima_show_type show,
+                                          enum data_formats datafmt,
+                                          struct ima_field_data *field_data)
+{
+        ima_putc(m, &field_data->len, sizeof(u32));
+        if (!field_data->len)
+                return;
+        ima_putc(m, field_data->data, field_data->len);
+}
+static void ima_show_template_field_data(struct seq_file *m,
+                                         enum ima_show_type show,
+                                         enum data_formats datafmt,
+                                         struct ima_field_data *field_data)
+{
+        switch (show) {
+        case IMA_SHOW_ASCII:
+                ima_show_template_data_ascii(m, show, datafmt, field_data);
+                break;
+        case IMA_SHOW_BINARY:
+                ima_show_template_data_binary(m, show, datafmt, field_data);
+                break;
+        default:
+                break;
+        }
+}
+void ima_show_template_digest(struct seq_file *m, enum ima_show_type show,
+                              struct ima_field_data *field_data)
+{
+        ima_show_template_field_data(m, show, DATA_FMT_DIGEST, field_data);
+}
+void ima_show_template_digest_ng(struct seq_file *m, enum ima_show_type show,
+                                 struct ima_field_data *field_data)
+{
+        ima_show_template_field_data(m, show, DATA_FMT_DIGEST_WITH_ALGO,
+                                     field_data);
+}
+void ima_show_template_string(struct seq_file *m, enum ima_show_type show,
+                              struct ima_field_data *field_data)
+{
+        ima_show_template_field_data(m, show, DATA_FMT_STRING, field_data);
+}
+void ima_show_template_sig(struct seq_file *m, enum ima_show_type show,
+                           struct ima_field_data *field_data)
+{
+        ima_show_template_field_data(m, show, DATA_FMT_HEX, field_data);
+}
+static int ima_eventdigest_init_common(u8 *digest, u32 digestsize, u8 hash_algo,
+                                       struct ima_field_data *field_data,
+                                       bool size_limit)
+{
+        /*
+         * digest formats:
+         *  - DATA_FMT_DIGEST: digest
+         *  - DATA_FMT_DIGEST_WITH_ALGO: [<hash algo>] + ':' + '\0' + digest,
+         *    where <hash algo> is provided if the hash algoritm is not
+         *    SHA1 or MD5
+         */
+        u8 buffer[CRYPTO_MAX_ALG_NAME + 2 + IMA_MAX_DIGEST_SIZE] = { 0 };
+        enum data_formats fmt = DATA_FMT_DIGEST;
+        u32 offset = 0;
+        if (!size_limit) {
+                fmt = DATA_FMT_DIGEST_WITH_ALGO;
+                if (hash_algo < HASH_ALGO__LAST)
+                        offset += snprintf(buffer, CRYPTO_MAX_ALG_NAME + 1,
+                                           "%s", hash_algo_name[hash_algo]);
+                buffer[offset] = ':';
+                offset += 2;
+        }
+        if (digest)
+                memcpy(buffer + offset, digest, digestsize);
+        else
+                /*
+                 * If digest is NULL, the event being recorded is a violation.
+                 * Make room for the digest by increasing the offset of
+                 * IMA_DIGEST_SIZE.
+                 */
+                offset += IMA_DIGEST_SIZE;
+        return ima_write_template_field_data(buffer, offset + digestsize,
+                                             fmt, field_data);
+}
+/*
+ * This function writes the digest of an event (with size limit).
+ */
+int ima_eventdigest_init(struct integrity_iint_cache *iint, struct file *file,
+                         const unsigned char *filename,
+                         struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                         struct ima_field_data *field_data)
+{
+        struct {
+                struct ima_digest_data hdr;
+                char digest[IMA_MAX_DIGEST_SIZE];
+        } hash;
+        u8 *cur_digest = NULL;
+        u32 cur_digestsize = 0;
+        struct inode *inode;
+        int result;
+        memset(&hash, 0, sizeof(hash));
+        if (!iint)              /* recording a violation. */
+                goto out;
+        if (ima_template_hash_algo_allowed(iint->ima_hash->algo)) {
+                cur_digest = iint->ima_hash->digest;
+                cur_digestsize = iint->ima_hash->length;
+                goto out;
+        }
+        if (!file)              /* missing info to re-calculate the digest */
+                return -EINVAL;
+        inode = file_inode(file);
+        hash.hdr.algo = ima_template_hash_algo_allowed(ima_hash_algo) ?
+            ima_hash_algo : HASH_ALGO_SHA1;
+        result = ima_calc_file_hash(file, &hash.hdr);
+        if (result) {
+                integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
+                                    filename, "collect_data",
+                                    "failed", result, 0);
+                return result;
+        }
+        cur_digest = hash.hdr.digest;
+        cur_digestsize = hash.hdr.length;
+out:
+        return ima_eventdigest_init_common(cur_digest, cur_digestsize, -1,
+                                           field_data, true);
+}
+/*
+ * This function writes the digest of an event (without size limit).
+ */
+int ima_eventdigest_ng_init(struct integrity_iint_cache *iint,
+                            struct file *file, const unsigned char *filename,
+                            struct evm_ima_xattr_data *xattr_value,
+                            int xattr_len, struct ima_field_data *field_data)
+{
+        u8 *cur_digest = NULL, hash_algo = HASH_ALGO__LAST;
+        u32 cur_digestsize = 0;
+        /* If iint is NULL, we are recording a violation. */
+        if (!iint)
+                goto out;
+        cur_digest = iint->ima_hash->digest;
+        cur_digestsize = iint->ima_hash->length;
+        hash_algo = iint->ima_hash->algo;
+out:
+        return ima_eventdigest_init_common(cur_digest, cur_digestsize,
+                                           hash_algo, field_data, false);
+}
+static int ima_eventname_init_common(struct integrity_iint_cache *iint,
+                                     struct file *file,
+                                     const unsigned char *filename,
+                                     struct ima_field_data *field_data,
+                                     bool size_limit)
+{
+        const char *cur_filename = NULL;
+        u32 cur_filename_len = 0;
+        enum data_formats fmt = size_limit ?
+            DATA_FMT_EVENT_NAME : DATA_FMT_STRING;
+        BUG_ON(filename == NULL && file == NULL);
+        if (filename) {
+                cur_filename = filename;
+                cur_filename_len = strlen(filename);
+                if (!size_limit || cur_filename_len <= IMA_EVENT_NAME_LEN_MAX)
+                        goto out;
+        }
+        if (file) {
+                cur_filename = file->f_dentry->d_name.name;
+                cur_filename_len = strlen(cur_filename);
+        } else
+                /*
+                 * Truncate filename if the latter is too long and
+                 * the file descriptor is not available.
+                 */
+                cur_filename_len = IMA_EVENT_NAME_LEN_MAX;
+out:
+        return ima_write_template_field_data(cur_filename, cur_filename_len,
+                                             fmt, field_data);
+}
+/*
+ * This function writes the name of an event (with size limit).
+ */
+int ima_eventname_init(struct integrity_iint_cache *iint, struct file *file,
+                       const unsigned char *filename,
+                       struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                       struct ima_field_data *field_data)
+{
+        return ima_eventname_init_common(iint, file, filename,
+                                         field_data, true);
+}
+/*
+ * This function writes the name of an event (without size limit).
+ */
+int ima_eventname_ng_init(struct integrity_iint_cache *iint, struct file *file,
+                          const unsigned char *filename,
+                          struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                          struct ima_field_data *field_data)
+{
+        return ima_eventname_init_common(iint, file, filename,
+                                         field_data, false);
+}
+/*
+ *  ima_eventsig_init - include the file signature as part of the template data
+ */
+int ima_eventsig_init(struct integrity_iint_cache *iint, struct file *file,
+                      const unsigned char *filename,
+                      struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                      struct ima_field_data *field_data)
+{
+        enum data_formats fmt = DATA_FMT_HEX;
+        int rc = 0;
+        if ((!xattr_value) || (xattr_value->type != EVM_IMA_XATTR_DIGSIG))
+                goto out;
+        rc = ima_write_template_field_data(xattr_value, xattr_len, fmt,
+                                           field_data);
+out:
+        return rc;
+}
diff --git a/security/integrity/ima/ima_template_lib.h b/security/integrity/ima/ima_template_lib.h
new file mode 100644
index 000000000000..63f6b52cb1c2
--- /dev/null
+++ b/security/integrity/ima/ima_template_lib.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2013 Politecnico di Torino, Italy
+ *                    TORSEC group -- http://security.polito.it
+ *
+ * Author: Roberto Sassu <roberto.sassu@polito.it>
+ *
+ * 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.
+ *
+ * File: ima_template_lib.h
+ *      Header for the library of supported template fields.
+ */
+#ifndef __LINUX_IMA_TEMPLATE_LIB_H
+#define __LINUX_IMA_TEMPLATE_LIB_H
+#include <linux/seq_file.h>
+#include "ima.h"
+void ima_show_template_digest(struct seq_file *m, enum ima_show_type show,
+                              struct ima_field_data *field_data);
+void ima_show_template_digest_ng(struct seq_file *m, enum ima_show_type show,
+                                 struct ima_field_data *field_data);
+void ima_show_template_string(struct seq_file *m, enum ima_show_type show,
+                              struct ima_field_data *field_data);
+void ima_show_template_sig(struct seq_file *m, enum ima_show_type show,
+                           struct ima_field_data *field_data);
+int ima_eventdigest_init(struct integrity_iint_cache *iint, struct file *file,
+                         const unsigned char *filename,
+                         struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                         struct ima_field_data *field_data);
+int ima_eventname_init(struct integrity_iint_cache *iint, struct file *file,
+                       const unsigned char *filename,
+                       struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                       struct ima_field_data *field_data);
+int ima_eventdigest_ng_init(struct integrity_iint_cache *iint,
+                            struct file *file, const unsigned char *filename,
+                            struct evm_ima_xattr_data *xattr_value,
+                            int xattr_len, struct ima_field_data *field_data);
+int ima_eventname_ng_init(struct integrity_iint_cache *iint, struct file *file,
+                          const unsigned char *filename,
+                          struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                          struct ima_field_data *field_data);
+int ima_eventsig_init(struct integrity_iint_cache *iint, struct file *file,
+                      const unsigned char *filename,
+                      struct evm_ima_xattr_data *xattr_value, int xattr_len,
+                      struct ima_field_data *field_data);
+#endif /* __LINUX_IMA_TEMPLATE_LIB_H */
diff --git a/security/integrity/integrity.h b/security/integrity/integrity.h
index c42fb7a70dee..b9e7c133734a 100644
--- a/security/integrity/integrity.h
+++ b/security/integrity/integrity.h
@@ -54,25 +54,57 @@ enum evm_ima_xattr_type {
        IMA_XATTR_DIGEST = 0x01,
        EVM_XATTR_HMAC,
        EVM_IMA_XATTR_DIGSIG,
+        IMA_XATTR_DIGEST_NG,
 };
 struct evm_ima_xattr_data {
        u8 type;
        u8 digest[SHA1_DIGEST_SIZE];
-}  __attribute__((packed));
+} __packed;
+#define IMA_MAX_DIGEST_SIZE     64
+struct ima_digest_data {
+        u8 algo;
+        u8 length;
+        union {
+                struct {
+                        u8 unused;
+                        u8 type;
+                } sha1;
+                struct {
+                        u8 type;
+                        u8 algo;
+                } ng;
+                u8 data[2];
+        } xattr;
+        u8 digest[0];
+} __packed;
+/*
+ * signature format v2 - for using with asymmetric keys
+ */
+struct signature_v2_hdr {
+        uint8_t type;           /* xattr type */
+        uint8_t version;        /* signature format version */
+        uint8_t hash_algo;      /* Digest algorithm [enum pkey_hash_algo] */
+        uint32_t keyid;         /* IMA key identifier - not X509/PGP specific */
+        uint16_t sig_size;      /* signature size */
+        uint8_t sig[0];         /* signature payload */
+} __packed;
 /* integrity data associated with an inode */
 struct integrity_iint_cache {
-        struct rb_node rb_node; /* rooted in integrity_iint_tree */
+        struct rb_node rb_node; /* rooted in integrity_iint_tree */
        struct inode *inode;    /* back pointer to inode in question */
        u64 version;            /* track inode changes */
        unsigned long flags;
-        struct evm_ima_xattr_data ima_xattr;
        enum integrity_status ima_file_status:4;
        enum integrity_status ima_mmap_status:4;
        enum integrity_status ima_bprm_status:4;
        enum integrity_status ima_module_status:4;
        enum integrity_status evm_status:4;
+        struct ima_digest_data *ima_hash;
 };
 /* rbtree tree calls to lookup, insert, delete
@@ -89,7 +121,7 @@ struct integrity_iint_cache *integrity_iint_find(struct inode *inode);
 #ifdef CONFIG_INTEGRITY_SIGNATURE
 int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,
-                                        const char *digest, int digestlen);
+                            const char *digest, int digestlen);
 #else
@@ -105,12 +137,19 @@ static inline int integrity_digsig_verify(const unsigned int id,
 #ifdef CONFIG_INTEGRITY_ASYMMETRIC_KEYS
 int asymmetric_verify(struct key *keyring, const char *sig,
                      int siglen, const char *data, int datalen);
+int integrity_init_keyring(const unsigned int id);
 #else
 static inline int asymmetric_verify(struct key *keyring, const char *sig,
                                    int siglen, const char *data, int datalen)
 {
        return -EOPNOTSUPP;
 }
+static int integrity_init_keyring(const unsigned int id)
+{
+        return 0;
+}
 #endif
 #ifdef CONFIG_INTEGRITY_AUDIT
diff --git a/security/keys/Kconfig b/security/keys/Kconfig
index a90d6d300dbd..a4f3f8c48d6e 100644
--- a/security/keys/Kconfig
+++ b/security/keys/Kconfig
@@ -4,6 +4,7 @@
 config KEYS
        bool "Enable access key retention support"
+        select ASSOCIATIVE_ARRAY
        help
          This option provides support for retaining authentication tokens and
          access keys in the kernel.
@@ -19,6 +20,34 @@ config KEYS
          If you are unsure as to whether this is required, answer N.
+config PERSISTENT_KEYRINGS
+        bool "Enable register of persistent per-UID keyrings"
+        depends on KEYS
+        help
+          This option provides a register of persistent per-UID keyrings,
+          primarily aimed at Kerberos key storage.  The keyrings are persistent
+          in the sense that they stay around after all processes of that UID
+          have exited, not that they survive the machine being rebooted.
+          A particular keyring may be accessed by either the user whose keyring
+          it is or by a process with administrative privileges.  The active
+          LSMs gets to rule on which admin-level processes get to access the
+          cache.
+          Keyrings are created and added into the register upon demand and get
+          removed if they expire (a default timeout is set upon creation).
+config BIG_KEYS
+        bool "Large payload keys"
+        depends on KEYS
+        depends on TMPFS
+        help
+          This option provides support for holding large keys within the kernel
+          (for example Kerberos ticket caches).  The data may be stored out to
+          swapspace by tmpfs.
+          If you are unsure as to whether this is required, answer N.
 config TRUSTED_KEYS
        tristate "TRUSTED KEYS"
        depends on KEYS && TCG_TPM
diff --git a/security/keys/Makefile b/security/keys/Makefile
index 504aaa008388..dfb3a7bededf 100644
--- a/security/keys/Makefile
+++ b/security/keys/Makefile
@@ -18,9 +18,11 @@ obj-y := \
 obj-$(CONFIG_KEYS_COMPAT) += compat.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_SYSCTL) += sysctl.o
+obj-$(CONFIG_PERSISTENT_KEYRINGS) += persistent.o
 #
 # Key types
 #
+obj-$(CONFIG_BIG_KEYS) += big_key.o
 obj-$(CONFIG_TRUSTED_KEYS) += trusted.o
 obj-$(CONFIG_ENCRYPTED_KEYS) += encrypted-keys/
diff --git a/security/keys/big_key.c b/security/keys/big_key.c
new file mode 100644
index 000000000000..7f44c3207a9b
--- /dev/null
+++ b/security/keys/big_key.c
@@ -0,0 +1,207 @@
+/* Large capacity key type
+ *
+ * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/seq_file.h>
+#include <linux/file.h>
+#include <linux/shmem_fs.h>
+#include <linux/err.h>
+#include <keys/user-type.h>
+#include <keys/big_key-type.h>
+MODULE_LICENSE("GPL");
+/*
+ * If the data is under this limit, there's no point creating a shm file to
+ * hold it as the permanently resident metadata for the shmem fs will be at
+ * least as large as the data.
+ */
+#define BIG_KEY_FILE_THRESHOLD (sizeof(struct inode) + sizeof(struct dentry))
+/*
+ * big_key defined keys take an arbitrary string as the description and an
+ * arbitrary blob of data as the payload
+ */
+struct key_type key_type_big_key = {
+        .name                   = "big_key",
+        .def_lookup_type        = KEYRING_SEARCH_LOOKUP_DIRECT,
+        .instantiate            = big_key_instantiate,
+        .match                  = user_match,
+        .revoke                 = big_key_revoke,
+        .destroy                = big_key_destroy,
+        .describe               = big_key_describe,
+        .read                   = big_key_read,
+};
+/*
+ * Instantiate a big key
+ */
+int big_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
+{
+        struct path *path = (struct path *)&key->payload.data2;
+        struct file *file;
+        ssize_t written;
+        size_t datalen = prep->datalen;
+        int ret;
+        ret = -EINVAL;
+        if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data)
+                goto error;
+        /* Set an arbitrary quota */
+        ret = key_payload_reserve(key, 16);
+        if (ret < 0)
+                goto error;
+        key->type_data.x[1] = datalen;
+        if (datalen > BIG_KEY_FILE_THRESHOLD) {
+                /* Create a shmem file to store the data in.  This will permit the data
+                 * to be swapped out if needed.
+                 *
+                 * TODO: Encrypt the stored data with a temporary key.
+                 */
+                file = shmem_file_setup("", datalen, 0);
+                if (IS_ERR(file)) {
+                        ret = PTR_ERR(file);
+                        goto err_quota;
+                }
+                written = kernel_write(file, prep->data, prep->datalen, 0);
+                if (written != datalen) {
+                        ret = written;
+                        if (written >= 0)
+                                ret = -ENOMEM;
+                        goto err_fput;
+                }
+                /* Pin the mount and dentry to the key so that we can open it again
+                 * later
+                 */
+                *path = file->f_path;
+                path_get(path);
+                fput(file);
+        } else {
+                /* Just store the data in a buffer */
+                void *data = kmalloc(datalen, GFP_KERNEL);
+                if (!data) {
+                        ret = -ENOMEM;
+                        goto err_quota;
+                }
+                key->payload.data = memcpy(data, prep->data, prep->datalen);
+        }
+        return 0;
+err_fput:
+        fput(file);
+err_quota:
+        key_payload_reserve(key, 0);
+error:
+        return ret;
+}
+/*
+ * dispose of the links from a revoked keyring
+ * - called with the key sem write-locked
+ */
+void big_key_revoke(struct key *key)
+{
+        struct path *path = (struct path *)&key->payload.data2;
+        /* clear the quota */
+        key_payload_reserve(key, 0);
+        if (key_is_instantiated(key) && key->type_data.x[1] > BIG_KEY_FILE_THRESHOLD)
+                vfs_truncate(path, 0);
+}
+/*
+ * dispose of the data dangling from the corpse of a big_key key
+ */
+void big_key_destroy(struct key *key)
+{
+        if (key->type_data.x[1] > BIG_KEY_FILE_THRESHOLD) {
+                struct path *path = (struct path *)&key->payload.data2;
+                path_put(path);
+                path->mnt = NULL;
+                path->dentry = NULL;
+        } else {
+                kfree(key->payload.data);
+                key->payload.data = NULL;
+        }
+}
+/*
+ * describe the big_key key
+ */
+void big_key_describe(const struct key *key, struct seq_file *m)
+{
+        unsigned long datalen = key->type_data.x[1];
+        seq_puts(m, key->description);
+        if (key_is_instantiated(key))
+                seq_printf(m, ": %lu [%s]",
+                           datalen,
+                           datalen > BIG_KEY_FILE_THRESHOLD ? "file" : "buff");
+}
+/*
+ * read the key data
+ * - the key's semaphore is read-locked
+ */
+long big_key_read(const struct key *key, char __user *buffer, size_t buflen)
+{
+        unsigned long datalen = key->type_data.x[1];
+        long ret;
+        if (!buffer || buflen < datalen)
+                return datalen;
+        if (datalen > BIG_KEY_FILE_THRESHOLD) {
+                struct path *path = (struct path *)&key->payload.data2;
+                struct file *file;
+                loff_t pos;
+                file = dentry_open(path, O_RDONLY, current_cred());
+                if (IS_ERR(file))
+                        return PTR_ERR(file);
+                pos = 0;
+                ret = vfs_read(file, buffer, datalen, &pos);
+                fput(file);
+                if (ret >= 0 && ret != datalen)
+                        ret = -EIO;
+        } else {
+                ret = datalen;
+                if (copy_to_user(buffer, key->payload.data, datalen) != 0)
+                        ret = -EFAULT;
+        }
+        return ret;
+}
+/*
+ * Module stuff
+ */
+static int __init big_key_init(void)
+{
+        return register_key_type(&key_type_big_key);
+}
+static void __exit big_key_cleanup(void)
+{
+        unregister_key_type(&key_type_big_key);
+}
+module_init(big_key_init);
+module_exit(big_key_cleanup);
diff --git a/security/keys/compat.c b/security/keys/compat.c
index d65fa7fa29ba..bbd32c729dbb 100644
--- a/security/keys/compat.c
+++ b/security/keys/compat.c
@@ -138,6 +138,9 @@ asmlinkage long compat_sys_keyctl(u32 option,
        case KEYCTL_INVALIDATE:
                return keyctl_invalidate_key(arg2);
+        case KEYCTL_GET_PERSISTENT:
+                return keyctl_get_persistent(arg2, arg3);
        default:
                return -EOPNOTSUPP;
        }
diff --git a/security/keys/gc.c b/security/keys/gc.c
index d67c97bb1025..d3222b6d7d59 100644
--- a/security/keys/gc.c
+++ b/security/keys/gc.c
@@ -131,50 +131,6 @@ void key_gc_keytype(struct key_type *ktype)
 }
 /*
- * Garbage collect pointers from a keyring.
- *
- * Not called with any locks held.  The keyring's key struct will not be
- * deallocated under us as only our caller may deallocate it.
- */
-static void key_gc_keyring(struct key *keyring, time_t limit)
-{
-        struct keyring_list *klist;
-        int loop;
-        kenter("%x", key_serial(keyring));
-        if (keyring->flags & ((1 << KEY_FLAG_INVALIDATED) |
-                              (1 << KEY_FLAG_REVOKED)))
-                goto dont_gc;
-        /* scan the keyring looking for dead keys */
-        rcu_read_lock();
-        klist = rcu_dereference(keyring->payload.subscriptions);
-        if (!klist)
-                goto unlock_dont_gc;
-        loop = klist->nkeys;
-        smp_rmb();
-        for (loop--; loop >= 0; loop--) {
-                struct key *key = rcu_dereference(klist->keys[loop]);
-                if (key_is_dead(key, limit))
-                        goto do_gc;
-        }
-unlock_dont_gc:
-        rcu_read_unlock();
-dont_gc:
-        kleave(" [no gc]");
-        return;
-do_gc:
-        rcu_read_unlock();
-        keyring_gc(keyring, limit);
-        kleave(" [gc]");
-}
-/*
 * Garbage collect a list of unreferenced, detached keys
 */
 static noinline void key_gc_unused_keys(struct list_head *keys)
@@ -392,8 +348,7 @@ found_unreferenced_key:
         */
 found_keyring:
        spin_unlock(&key_serial_lock);
-        kdebug("scan keyring %d", key->serial);
+        keyring_gc(key, limit);
-        key_gc_keyring(key, limit);
        goto maybe_resched;
        /* We found a dead key that is still referenced.  Reset its type and
diff --git a/security/keys/internal.h b/security/keys/internal.h
index d4f1468b9b50..80b2aac4f50c 100644
--- a/security/keys/internal.h
+++ b/security/keys/internal.h
@@ -89,42 +89,53 @@ extern struct key_type *key_type_lookup(const char *type);
 extern void key_type_put(struct key_type *ktype);
 extern int __key_link_begin(struct key *keyring,
-                            const struct key_type *type,
+                            const struct keyring_index_key *index_key,
-                            const char *description,
+                            struct assoc_array_edit **_edit);
-                            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,
+extern void __key_link(struct key *key, struct assoc_array_edit **_edit);
-                       unsigned long *_prealloc);
 extern void __key_link_end(struct key *keyring,
-                           struct key_type *type,
+                           const struct keyring_index_key *index_key,
-                           unsigned long prealloc);
+                           struct assoc_array_edit *edit);
-extern key_ref_t __keyring_search_one(key_ref_t keyring_ref,
+extern key_ref_t find_key_to_update(key_ref_t keyring_ref,
-                                      const struct key_type *type,
+                                    const struct keyring_index_key *index_key);
-                                      const char *description,
-                                      key_perm_t perm);
 extern struct key *keyring_search_instkey(struct key *keyring,
                                          key_serial_t target_id);
+extern int iterate_over_keyring(const struct key *keyring,
+                                int (*func)(const struct key *key, void *data),
+                                void *data);
 typedef int (*key_match_func_t)(const struct key *, const void *);
+struct keyring_search_context {
+        struct keyring_index_key index_key;
+        const struct cred       *cred;
+        key_match_func_t        match;
+        const void              *match_data;
+        unsigned                flags;
+#define KEYRING_SEARCH_LOOKUP_TYPE      0x0001  /* [as type->def_lookup_type] */
+#define KEYRING_SEARCH_NO_STATE_CHECK   0x0002  /* Skip state checks */
+#define KEYRING_SEARCH_DO_STATE_CHECK   0x0004  /* Override NO_STATE_CHECK */
+#define KEYRING_SEARCH_NO_UPDATE_TIME   0x0008  /* Don't update times */
+#define KEYRING_SEARCH_NO_CHECK_PERM    0x0010  /* Don't check permissions */
+#define KEYRING_SEARCH_DETECT_TOO_DEEP  0x0020  /* Give an error on excessive depth */
+        int (*iterator)(const void *object, void *iterator_data);
+        /* Internal stuff */
+        int                     skipped_ret;
+        bool                    possessed;
+        key_ref_t               result;
+        struct timespec         now;
+};
 extern key_ref_t keyring_search_aux(key_ref_t keyring_ref,
-                                    const struct cred *cred,
+                                    struct keyring_search_context *ctx);
-                                    struct key_type *type,
-                                    const void *description,
+extern key_ref_t search_my_process_keyrings(struct keyring_search_context *ctx);
-                                    key_match_func_t match,
+extern key_ref_t search_process_keyrings(struct keyring_search_context *ctx);
-                                    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,
-                                         key_match_func_t match,
-                                         const struct cred *cred);
 extern struct key *find_keyring_by_name(const char *name, bool skip_perm_check);
@@ -202,7 +213,7 @@ extern struct key *key_get_instantiation_authkey(key_serial_t target_id);
 /*
 * Determine whether a key is dead.
 */
-static inline bool key_is_dead(struct key *key, time_t limit)
+static inline bool key_is_dead(const struct key *key, time_t limit)
 {
        return
                key->flags & ((1 << KEY_FLAG_DEAD) |
@@ -244,6 +255,15 @@ extern long keyctl_invalidate_key(key_serial_t);
 extern long keyctl_instantiate_key_common(key_serial_t,
                                          const struct iovec *,
                                          unsigned, size_t, key_serial_t);
+#ifdef CONFIG_PERSISTENT_KEYRINGS
+extern long keyctl_get_persistent(uid_t, key_serial_t);
+extern unsigned persistent_keyring_expiry;
+#else
+static inline long keyctl_get_persistent(uid_t uid, key_serial_t destring)
+{
+        return -EOPNOTSUPP;
+}
+#endif
 /*
 * Debugging key validation
diff --git a/security/keys/key.c b/security/keys/key.c
index 8fb7c7bd4657..55d110f0aced 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -242,8 +242,8 @@ struct key *key_alloc(struct key_type *type, const char *desc,
                }
        }
-        desclen = strlen(desc) + 1;
+        desclen = strlen(desc);
-        quotalen = desclen + type->def_datalen;
+        quotalen = desclen + 1 + type->def_datalen;
        /* get hold of the key tracking for this user */
        user = key_user_lookup(uid);
@@ -277,7 +277,8 @@ struct key *key_alloc(struct key_type *type, const char *desc,
                goto no_memory_2;
        if (desc) {
-                key->description = kmemdup(desc, desclen, GFP_KERNEL);
+                key->index_key.desc_len = desclen;
+                key->index_key.description = kmemdup(desc, desclen + 1, GFP_KERNEL);
                if (!key->description)
                        goto no_memory_3;
        }
@@ -285,7 +286,7 @@ struct key *key_alloc(struct key_type *type, const char *desc,
        atomic_set(&key->usage, 1);
        init_rwsem(&key->sem);
        lockdep_set_class(&key->sem, &type->lock_class);
-        key->type = type;
+        key->index_key.type = type;
        key->user = user;
        key->quotalen = quotalen;
        key->datalen = type->def_datalen;
@@ -299,6 +300,8 @@ struct key *key_alloc(struct key_type *type, const char *desc,
        if (!(flags & KEY_ALLOC_NOT_IN_QUOTA))
                key->flags |= 1 << KEY_FLAG_IN_QUOTA;
+        if (flags & KEY_ALLOC_TRUSTED)
+                key->flags |= 1 << KEY_FLAG_TRUSTED;
        memset(&key->type_data, 0, sizeof(key->type_data));
@@ -408,7 +411,7 @@ static int __key_instantiate_and_link(struct key *key,
                                      struct key_preparsed_payload *prep,
                                      struct key *keyring,
                                      struct key *authkey,
-                                      unsigned long *_prealloc)
+                                      struct assoc_array_edit **_edit)
 {
        int ret, awaken;
@@ -435,7 +438,7 @@ static int __key_instantiate_and_link(struct key *key,
                        /* and link it into the destination keyring */
                        if (keyring)
-                                __key_link(keyring, key, _prealloc);
+                                __key_link(key, _edit);
                        /* disable the authorisation key */
                        if (authkey)
@@ -475,7 +478,7 @@ int key_instantiate_and_link(struct key *key,
                             struct key *authkey)
 {
        struct key_preparsed_payload prep;
-        unsigned long prealloc;
+        struct assoc_array_edit *edit;
        int ret;
        memset(&prep, 0, sizeof(prep));
@@ -489,17 +492,15 @@ int key_instantiate_and_link(struct key *key,
        }
        if (keyring) {
-                ret = __key_link_begin(keyring, key->type, key->description,
+                ret = __key_link_begin(keyring, &key->index_key, &edit);
-                                       &prealloc);
                if (ret < 0)
                        goto error_free_preparse;
        }
-        ret = __key_instantiate_and_link(key, &prep, keyring, authkey,
+        ret = __key_instantiate_and_link(key, &prep, keyring, authkey, &edit);
-                                         &prealloc);
        if (keyring)
-                __key_link_end(keyring, key->type, prealloc);
+                __key_link_end(keyring, &key->index_key, edit);
 error_free_preparse:
        if (key->type->preparse)
@@ -537,7 +538,7 @@ int key_reject_and_link(struct key *key,
                        struct key *keyring,
                        struct key *authkey)
 {
-        unsigned long prealloc;
+        struct assoc_array_edit *edit;
        struct timespec now;
        int ret, awaken, link_ret = 0;
@@ -548,8 +549,7 @@ int key_reject_and_link(struct key *key,
        ret = -EBUSY;
        if (keyring)
-                link_ret = __key_link_begin(keyring, key->type,
+                link_ret = __key_link_begin(keyring, &key->index_key, &edit);
-                                            key->description, &prealloc);
        mutex_lock(&key_construction_mutex);
@@ -557,9 +557,10 @@ int key_reject_and_link(struct key *key,
        if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
                /* mark the key as being negatively instantiated */
                atomic_inc(&key->user->nikeys);
+                key->type_data.reject_error = -error;
+                smp_wmb();
                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);
@@ -571,7 +572,7 @@ int key_reject_and_link(struct key *key,
                /* and link it into the destination keyring */
                if (keyring && link_ret == 0)
-                        __key_link(keyring, key, &prealloc);
+                        __key_link(key, &edit);
                /* disable the authorisation key */
                if (authkey)
@@ -581,7 +582,7 @@ int key_reject_and_link(struct key *key,
        mutex_unlock(&key_construction_mutex);
        if (keyring)
-                __key_link_end(keyring, key->type, prealloc);
+                __key_link_end(keyring, &key->index_key, edit);
        /* wake up anyone waiting for a key to be constructed */
        if (awaken)
@@ -645,7 +646,7 @@ found:
        /* this races with key_put(), but that doesn't matter since key_put()
         * doesn't actually change the key
         */
-        atomic_inc(&key->usage);
+        __key_get(key);
 error:
        spin_unlock(&key_serial_lock);
@@ -780,25 +781,27 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
                               key_perm_t perm,
                               unsigned long flags)
 {
-        unsigned long prealloc;
+        struct keyring_index_key index_key = {
+                .description    = description,
+        };
        struct key_preparsed_payload prep;
+        struct assoc_array_edit *edit;
        const struct cred *cred = current_cred();
-        struct key_type *ktype;
        struct key *keyring, *key = NULL;
        key_ref_t key_ref;
        int ret;
        /* look up the key type to see if it's one of the registered kernel
         * types */
-        ktype = key_type_lookup(type);
+        index_key.type = key_type_lookup(type);
-        if (IS_ERR(ktype)) {
+        if (IS_ERR(index_key.type)) {
                key_ref = ERR_PTR(-ENODEV);
                goto error;
        }
        key_ref = ERR_PTR(-EINVAL);
-        if (!ktype->match || !ktype->instantiate ||
+        if (!index_key.type->match || !index_key.type->instantiate ||
-            (!description && !ktype->preparse))
+            (!index_key.description && !index_key.type->preparse))
                goto error_put_type;
        keyring = key_ref_to_ptr(keyring_ref);
@@ -812,21 +815,28 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
        memset(&prep, 0, sizeof(prep));
        prep.data = payload;
        prep.datalen = plen;
-        prep.quotalen = ktype->def_datalen;
+        prep.quotalen = index_key.type->def_datalen;
-        if (ktype->preparse) {
+        prep.trusted = flags & KEY_ALLOC_TRUSTED;
-                ret = ktype->preparse(&prep);
+        if (index_key.type->preparse) {
+                ret = index_key.type->preparse(&prep);
                if (ret < 0) {
                        key_ref = ERR_PTR(ret);
                        goto error_put_type;
                }
-                if (!description)
+                if (!index_key.description)
-                        description = prep.description;
+                        index_key.description = prep.description;
                key_ref = ERR_PTR(-EINVAL);
-                if (!description)
+                if (!index_key.description)
                        goto error_free_prep;
        }
+        index_key.desc_len = strlen(index_key.description);
+        key_ref = ERR_PTR(-EPERM);
+        if (!prep.trusted && test_bit(KEY_FLAG_TRUSTED_ONLY, &keyring->flags))
+                goto error_free_prep;
+        flags |= prep.trusted ? KEY_ALLOC_TRUSTED : 0;
-        ret = __key_link_begin(keyring, ktype, description, &prealloc);
+        ret = __key_link_begin(keyring, &index_key, &edit);
        if (ret < 0) {
                key_ref = ERR_PTR(ret);
                goto error_free_prep;
@@ -844,10 +854,9 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
         * key of the same type and description in the destination keyring and
         * update that instead if possible
         */
-        if (ktype->update) {
+        if (index_key.type->update) {
-                key_ref = __keyring_search_one(keyring_ref, ktype, description,
+                key_ref = find_key_to_update(keyring_ref, &index_key);
-                                               0);
+                if (key_ref)
-                if (!IS_ERR(key_ref))
                        goto found_matching_key;
        }
@@ -856,23 +865,24 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
                perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
                perm |= KEY_USR_VIEW;
-                if (ktype->read)
+                if (index_key.type->read)
                        perm |= KEY_POS_READ;
-                if (ktype == &key_type_keyring || ktype->update)
+                if (index_key.type == &key_type_keyring ||
+                    index_key.type->update)
                        perm |= KEY_POS_WRITE;
        }
        /* allocate a new key */
-        key = key_alloc(ktype, description, cred->fsuid, cred->fsgid, cred,
+        key = key_alloc(index_key.type, index_key.description,
-                        perm, flags);
+                        cred->fsuid, cred->fsgid, cred, perm, flags);
        if (IS_ERR(key)) {
                key_ref = ERR_CAST(key);
                goto error_link_end;
        }
        /* instantiate it and link it into the target keyring */
-        ret = __key_instantiate_and_link(key, &prep, keyring, NULL, &prealloc);
+        ret = __key_instantiate_and_link(key, &prep, keyring, NULL, &edit);
        if (ret < 0) {
                key_put(key);
                key_ref = ERR_PTR(ret);
@@ -882,12 +892,12 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
        key_ref = make_key_ref(key, is_key_possessed(keyring_ref));
 error_link_end:
-        __key_link_end(keyring, ktype, prealloc);
+        __key_link_end(keyring, &index_key, edit);
 error_free_prep:
-        if (ktype->preparse)
+        if (index_key.type->preparse)
-                ktype->free_preparse(&prep);
+                index_key.type->free_preparse(&prep);
 error_put_type:
-        key_type_put(ktype);
+        key_type_put(index_key.type);
 error:
        return key_ref;
@@ -895,7 +905,7 @@ error:
        /* we found a matching key, so we're going to try to update it
         * - we can drop the locks first as we have the key pinned
         */
-        __key_link_end(keyring, ktype, prealloc);
+        __key_link_end(keyring, &index_key, edit);
        key_ref = __key_update(key_ref, &prep);
        goto error_free_prep;
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index 33cfd27b4de2..cee72ce64222 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -1667,6 +1667,9 @@ SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3,
        case KEYCTL_INVALIDATE:
                return keyctl_invalidate_key((key_serial_t) arg2);
+        case KEYCTL_GET_PERSISTENT:
+                return keyctl_get_persistent((uid_t)arg2, (key_serial_t)arg3);
        default:
                return -EOPNOTSUPP;
        }
diff --git a/security/keys/keyring.c b/security/keys/keyring.c
index 6ece7f2e5707..69f0cb7bab7e 100644
--- a/security/keys/keyring.c
+++ b/security/keys/keyring.c
@@ -1,6 +1,6 @@
 /* Keyring handling
 *
- * Copyright (C) 2004-2005, 2008 Red Hat, Inc. All Rights Reserved.
+ * Copyright (C) 2004-2005, 2008, 2013 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
@@ -17,25 +17,11 @@
 #include <linux/seq_file.h>
 #include <linux/err.h>
 #include <keys/keyring-type.h>
+#include <keys/user-type.h>
+#include <linux/assoc_array_priv.h>
 #include <linux/uaccess.h>
 #include "internal.h"
-#define rcu_dereference_locked_keyring(keyring)                         \
-        (rcu_dereference_protected(                                     \
-                (keyring)->payload.subscriptions,                       \
-                rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
-#define rcu_deref_link_locked(klist, index, keyring)                    \
-        (rcu_dereference_protected(                                     \
-                (klist)->keys[index],                                   \
-                rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
-#define MAX_KEYRING_LINKS                                               \
-        min_t(size_t, USHRT_MAX - 1,                                    \
-              ((PAGE_SIZE - sizeof(struct keyring_list)) / sizeof(struct key *)))
-#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.
@@ -47,6 +33,28 @@
 */
 #define KEYRING_NAME_HASH_SIZE  (1 << 5)
+/*
+ * We mark pointers we pass to the associative array with bit 1 set if
+ * they're keyrings and clear otherwise.
+ */
+#define KEYRING_PTR_SUBTYPE     0x2UL
+static inline bool keyring_ptr_is_keyring(const struct assoc_array_ptr *x)
+{
+        return (unsigned long)x & KEYRING_PTR_SUBTYPE;
+}
+static inline struct key *keyring_ptr_to_key(const struct assoc_array_ptr *x)
+{
+        void *object = assoc_array_ptr_to_leaf(x);
+        return (struct key *)((unsigned long)object & ~KEYRING_PTR_SUBTYPE);
+}
+static inline void *keyring_key_to_ptr(struct key *key)
+{
+        if (key->type == &key_type_keyring)
+                return (void *)((unsigned long)key | KEYRING_PTR_SUBTYPE);
+        return key;
+}
 static struct list_head keyring_name_hash[KEYRING_NAME_HASH_SIZE];
 static DEFINE_RWLOCK(keyring_name_lock);
@@ -67,7 +75,6 @@ static inline unsigned keyring_hash(const char *desc)
 */
 static int keyring_instantiate(struct key *keyring,
                               struct key_preparsed_payload *prep);
-static int keyring_match(const struct key *keyring, const void *criterion);
 static void keyring_revoke(struct key *keyring);
 static void keyring_destroy(struct key *keyring);
 static void keyring_describe(const struct key *keyring, struct seq_file *m);
@@ -76,9 +83,9 @@ static long keyring_read(const struct key *keyring,
 struct key_type key_type_keyring = {
        .name           = "keyring",
-        .def_datalen    = sizeof(struct keyring_list),
+        .def_datalen    = 0,
        .instantiate    = keyring_instantiate,
-        .match          = keyring_match,
+        .match          = user_match,
        .revoke         = keyring_revoke,
        .destroy        = keyring_destroy,
        .describe       = keyring_describe,
@@ -127,6 +134,7 @@ static int keyring_instantiate(struct key *keyring,
        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;
@@ -136,15 +144,226 @@ static int keyring_instantiate(struct key *keyring,
 }
 /*
- * Match keyrings on their name
+ * Multiply 64-bits by 32-bits to 96-bits and fold back to 64-bit.  Ideally we'd
+ * fold the carry back too, but that requires inline asm.
+ */
+static u64 mult_64x32_and_fold(u64 x, u32 y)
+{
+        u64 hi = (u64)(u32)(x >> 32) * y;
+        u64 lo = (u64)(u32)(x) * y;
+        return lo + ((u64)(u32)hi << 32) + (u32)(hi >> 32);
+}
+/*
+ * Hash a key type and description.
+ */
+static unsigned long hash_key_type_and_desc(const struct keyring_index_key *index_key)
+{
+        const unsigned level_shift = ASSOC_ARRAY_LEVEL_STEP;
+        const unsigned long level_mask = ASSOC_ARRAY_LEVEL_STEP_MASK;
+        const char *description = index_key->description;
+        unsigned long hash, type;
+        u32 piece;
+        u64 acc;
+        int n, desc_len = index_key->desc_len;
+        type = (unsigned long)index_key->type;
+        acc = mult_64x32_and_fold(type, desc_len + 13);
+        acc = mult_64x32_and_fold(acc, 9207);
+        for (;;) {
+                n = desc_len;
+                if (n <= 0)
+                        break;
+                if (n > 4)
+                        n = 4;
+                piece = 0;
+                memcpy(&piece, description, n);
+                description += n;
+                desc_len -= n;
+                acc = mult_64x32_and_fold(acc, piece);
+                acc = mult_64x32_and_fold(acc, 9207);
+        }
+        /* Fold the hash down to 32 bits if need be. */
+        hash = acc;
+        if (ASSOC_ARRAY_KEY_CHUNK_SIZE == 32)
+                hash ^= acc >> 32;
+        /* Squidge all the keyrings into a separate part of the tree to
+         * ordinary keys by making sure the lowest level segment in the hash is
+         * zero for keyrings and non-zero otherwise.
+         */
+        if (index_key->type != &key_type_keyring && (hash & level_mask) == 0)
+                return hash | (hash >> (ASSOC_ARRAY_KEY_CHUNK_SIZE - level_shift)) | 1;
+        if (index_key->type == &key_type_keyring && (hash & level_mask) != 0)
+                return (hash + (hash << level_shift)) & ~level_mask;
+        return hash;
+}
+/*
+ * Build the next index key chunk.
+ *
+ * On 32-bit systems the index key is laid out as:
+ *
+ *      0       4       5       9...
+ *      hash    desclen typeptr desc[]
+ *
+ * On 64-bit systems:
+ *
+ *      0       8       9       17...
+ *      hash    desclen typeptr desc[]
+ *
+ * We return it one word-sized chunk at a time.
 */
-static int keyring_match(const struct key *keyring, const void *description)
+static unsigned long keyring_get_key_chunk(const void *data, int level)
+{
+        const struct keyring_index_key *index_key = data;
+        unsigned long chunk = 0;
+        long offset = 0;
+        int desc_len = index_key->desc_len, n = sizeof(chunk);
+        level /= ASSOC_ARRAY_KEY_CHUNK_SIZE;
+        switch (level) {
+        case 0:
+                return hash_key_type_and_desc(index_key);
+        case 1:
+                return ((unsigned long)index_key->type << 8) | desc_len;
+        case 2:
+                if (desc_len == 0)
+                        return (u8)((unsigned long)index_key->type >>
+                                    (ASSOC_ARRAY_KEY_CHUNK_SIZE - 8));
+                n--;
+                offset = 1;
+        default:
+                offset += sizeof(chunk) - 1;
+                offset += (level - 3) * sizeof(chunk);
+                if (offset >= desc_len)
+                        return 0;
+                desc_len -= offset;
+                if (desc_len > n)
+                        desc_len = n;
+                offset += desc_len;
+                do {
+                        chunk <<= 8;
+                        chunk |= ((u8*)index_key->description)[--offset];
+                } while (--desc_len > 0);
+                if (level == 2) {
+                        chunk <<= 8;
+                        chunk |= (u8)((unsigned long)index_key->type >>
+                                      (ASSOC_ARRAY_KEY_CHUNK_SIZE - 8));
+                }
+                return chunk;
+        }
+}
+static unsigned long keyring_get_object_key_chunk(const void *object, int level)
+{
+        const struct key *key = keyring_ptr_to_key(object);
+        return keyring_get_key_chunk(&key->index_key, level);
+}
+static bool keyring_compare_object(const void *object, const void *data)
 {
-        return keyring->description &&
+        const struct keyring_index_key *index_key = data;
-                strcmp(keyring->description, description) == 0;
+        const struct key *key = keyring_ptr_to_key(object);
+        return key->index_key.type == index_key->type &&
+                key->index_key.desc_len == index_key->desc_len &&
+                memcmp(key->index_key.description, index_key->description,
+                       index_key->desc_len) == 0;
 }
 /*
+ * Compare the index keys of a pair of objects and determine the bit position
+ * at which they differ - if they differ.
+ */
+static int keyring_diff_objects(const void *_a, const void *_b)
+{
+        const struct key *key_a = keyring_ptr_to_key(_a);
+        const struct key *key_b = keyring_ptr_to_key(_b);
+        const struct keyring_index_key *a = &key_a->index_key;
+        const struct keyring_index_key *b = &key_b->index_key;
+        unsigned long seg_a, seg_b;
+        int level, i;
+        level = 0;
+        seg_a = hash_key_type_and_desc(a);
+        seg_b = hash_key_type_and_desc(b);
+        if ((seg_a ^ seg_b) != 0)
+                goto differ;
+        /* The number of bits contributed by the hash is controlled by a
+         * constant in the assoc_array headers.  Everything else thereafter we
+         * can deal with as being machine word-size dependent.
+         */
+        level += ASSOC_ARRAY_KEY_CHUNK_SIZE / 8;
+        seg_a = a->desc_len;
+        seg_b = b->desc_len;
+        if ((seg_a ^ seg_b) != 0)
+                goto differ;
+        /* The next bit may not work on big endian */
+        level++;
+        seg_a = (unsigned long)a->type;
+        seg_b = (unsigned long)b->type;
+        if ((seg_a ^ seg_b) != 0)
+                goto differ;
+        level += sizeof(unsigned long);
+        if (a->desc_len == 0)
+                goto same;
+        i = 0;
+        if (((unsigned long)a->description | (unsigned long)b->description) &
+            (sizeof(unsigned long) - 1)) {
+                do {
+                        seg_a = *(unsigned long *)(a->description + i);
+                        seg_b = *(unsigned long *)(b->description + i);
+                        if ((seg_a ^ seg_b) != 0)
+                                goto differ_plus_i;
+                        i += sizeof(unsigned long);
+                } while (i < (a->desc_len & (sizeof(unsigned long) - 1)));
+        }
+        for (; i < a->desc_len; i++) {
+                seg_a = *(unsigned char *)(a->description + i);
+                seg_b = *(unsigned char *)(b->description + i);
+                if ((seg_a ^ seg_b) != 0)
+                        goto differ_plus_i;
+        }
+same:
+        return -1;
+differ_plus_i:
+        level += i;
+differ:
+        i = level * 8 + __ffs(seg_a ^ seg_b);
+        return i;
+}
+/*
+ * Free an object after stripping the keyring flag off of the pointer.
+ */
+static void keyring_free_object(void *object)
+{
+        key_put(keyring_ptr_to_key(object));
+}
+/*
+ * Operations for keyring management by the index-tree routines.
+ */
+static const struct assoc_array_ops keyring_assoc_array_ops = {
+        .get_key_chunk          = keyring_get_key_chunk,
+        .get_object_key_chunk   = keyring_get_object_key_chunk,
+        .compare_object         = keyring_compare_object,
+        .diff_objects           = keyring_diff_objects,
+        .free_object            = keyring_free_object,
+};
+/*
 * Clean up a keyring when it is destroyed.  Unpublish its name if it had one
 * and dispose of its data.
 *
@@ -155,9 +374,6 @@ static int keyring_match(const struct key *keyring, const void *description)
 */
 static void keyring_destroy(struct key *keyring)
 {
-        struct keyring_list *klist;
-        int loop;
        if (keyring->description) {
                write_lock(&keyring_name_lock);
@@ -168,12 +384,7 @@ static void keyring_destroy(struct key *keyring)
                write_unlock(&keyring_name_lock);
        }
-        klist = rcu_access_pointer(keyring->payload.subscriptions);
+        assoc_array_destroy(&keyring->keys, &keyring_assoc_array_ops);
-        if (klist) {
-                for (loop = klist->nkeys - 1; loop >= 0; loop--)
-                        key_put(rcu_access_pointer(klist->keys[loop]));
-                kfree(klist);
-        }
 }
 /*
@@ -181,76 +392,88 @@ static void keyring_destroy(struct key *keyring)
 */
 static void keyring_describe(const struct key *keyring, struct seq_file *m)
 {
-        struct keyring_list *klist;
        if (keyring->description)
                seq_puts(m, keyring->description);
        else
                seq_puts(m, "[anon]");
        if (key_is_instantiated(keyring)) {
-                rcu_read_lock();
+                if (keyring->keys.nr_leaves_on_tree != 0)
-                klist = rcu_dereference(keyring->payload.subscriptions);
+                        seq_printf(m, ": %lu", keyring->keys.nr_leaves_on_tree);
-                if (klist)
-                        seq_printf(m, ": %u/%u", klist->nkeys, klist->maxkeys);
                else
                        seq_puts(m, ": empty");
-                rcu_read_unlock();
        }
 }
+struct keyring_read_iterator_context {
+        size_t                  qty;
+        size_t                  count;
+        key_serial_t __user     *buffer;
+};
+static int keyring_read_iterator(const void *object, void *data)
+{
+        struct keyring_read_iterator_context *ctx = data;
+        const struct key *key = keyring_ptr_to_key(object);
+        int ret;
+        kenter("{%s,%d},,{%zu/%zu}",
+               key->type->name, key->serial, ctx->count, ctx->qty);
+        if (ctx->count >= ctx->qty)
+                return 1;
+        ret = put_user(key->serial, ctx->buffer);
+        if (ret < 0)
+                return ret;
+        ctx->buffer++;
+        ctx->count += sizeof(key->serial);
+        return 0;
+}
 /*
 * Read a list of key IDs from the keyring's contents in binary form
 *
- * The keyring's semaphore is read-locked by the caller.
+ * The keyring's semaphore is read-locked by the caller.  This prevents someone
+ * from modifying it under us - which could cause us to read key IDs multiple
+ * times.
 */
 static long keyring_read(const struct key *keyring,
                         char __user *buffer, size_t buflen)
 {
-        struct keyring_list *klist;
+        struct keyring_read_iterator_context ctx;
-        struct key *key;
+        unsigned long nr_keys;
-        size_t qty, tmp;
+        int ret;
-        int loop, ret;
-        ret = 0;
+        kenter("{%d},,%zu", key_serial(keyring), buflen);
-        klist = rcu_dereference_locked_keyring(keyring);
-        if (klist) {
+        if (buflen & (sizeof(key_serial_t) - 1))
-                /* calculate how much data we could return */
+                return -EINVAL;
-                qty = klist->nkeys * sizeof(key_serial_t);
+        nr_keys = keyring->keys.nr_leaves_on_tree;
-                if (buffer && buflen > 0) {
+        if (nr_keys == 0)
-                        if (buflen > qty)
+                return 0;
-                                buflen = qty;
-                        /* copy the IDs of the subscribed keys into the
-                         * buffer */
-                        ret = -EFAULT;
-                        for (loop = 0; loop < klist->nkeys; loop++) {
-                                key = rcu_deref_link_locked(klist, loop,
-                                                            keyring);
-                                tmp = sizeof(key_serial_t);
-                                if (tmp > buflen)
-                                        tmp = buflen;
-                                if (copy_to_user(buffer,
-                                                 &key->serial,
-                                                 tmp) != 0)
-                                        goto error;
-                                buflen -= tmp;
-                                if (buflen == 0)
-                                        break;
-                                buffer += tmp;
-                        }
-                }
-                ret = qty;
+        /* Calculate how much data we could return */
+        ctx.qty = nr_keys * sizeof(key_serial_t);
+        if (!buffer || !buflen)
+                return ctx.qty;
+        if (buflen > ctx.qty)
+                ctx.qty = buflen;
+        /* Copy the IDs of the subscribed keys into the buffer */
+        ctx.buffer = (key_serial_t __user *)buffer;
+        ctx.count = 0;
+        ret = assoc_array_iterate(&keyring->keys, keyring_read_iterator, &ctx);
+        if (ret < 0) {
+                kleave(" = %d [iterate]", ret);
+                return ret;
        }
-error:
+        kleave(" = %zu [ok]", ctx.count);
-        return ret;
+        return ctx.count;
 }
 /*
@@ -277,227 +500,361 @@ struct key *keyring_alloc(const char *description, kuid_t uid, kgid_t gid,
 }
 EXPORT_SYMBOL(keyring_alloc);
-/**
+/*
- * keyring_search_aux - Search a keyring tree for a key matching some criteria
+ * Iteration function to consider each key found.
- * @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,
+static int keyring_search_iterator(const void *object, void *iterator_data)
-                             const struct cred *cred,
-                             struct key_type *type,
-                             const void *description,
-                             key_match_func_t match,
-                             bool no_state_check)
 {
-        struct {
+        struct keyring_search_context *ctx = iterator_data;
-                /* Need a separate keylist pointer for RCU purposes */
+        const struct key *key = keyring_ptr_to_key(object);
-                struct key *keyring;
+        unsigned long kflags = key->flags;
-                struct keyring_list *keylist;
-                int kix;
-        } stack[KEYRING_SEARCH_MAX_DEPTH];
-        struct keyring_list *keylist;
-        struct timespec now;
-        unsigned long possessed, kflags;
-        struct key *keyring, *key;
-        key_ref_t key_ref;
-        long err;
-        int sp, nkeys, kix;
-        keyring = key_ref_to_ptr(keyring_ref);
+        kenter("{%d}", key->serial);
-        possessed = is_key_possessed(keyring_ref);
-        key_check(keyring);
-        /* top keyring must have search permission to begin the search */
+        /* ignore keys not of this type */
-        err = key_task_permission(keyring_ref, cred, KEY_SEARCH);
+        if (key->type != ctx->index_key.type) {
-        if (err < 0) {
+                kleave(" = 0 [!type]");
-                key_ref = ERR_PTR(err);
+                return 0;
-                goto error;
        }
-        key_ref = ERR_PTR(-ENOTDIR);
+        /* skip invalidated, revoked and expired keys */
-        if (keyring->type != &key_type_keyring)
+        if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) {
-                goto error;
+                if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
+                              (1 << KEY_FLAG_REVOKED))) {
+                        ctx->result = ERR_PTR(-EKEYREVOKED);
+                        kleave(" = %d [invrev]", ctx->skipped_ret);
+                        goto skipped;
+                }
-        rcu_read_lock();
+                if (key->expiry && ctx->now.tv_sec >= key->expiry) {
+                        ctx->result = ERR_PTR(-EKEYEXPIRED);
+                        kleave(" = %d [expire]", ctx->skipped_ret);
+                        goto skipped;
+                }
+        }
-        now = current_kernel_time();
+        /* keys that don't match */
-        err = -EAGAIN;
+        if (!ctx->match(key, ctx->match_data)) {
-        sp = 0;
+                kleave(" = 0 [!match]");
+                return 0;
-        /* firstly we should check to see if this top-level keyring is what we
+        }
-         * are looking for */
-        key_ref = ERR_PTR(-EAGAIN);
-        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
+        /* key must have search permissions */
-                 * revoked */
+        if (!(ctx->flags & KEYRING_SEARCH_NO_CHECK_PERM) &&
-                if (kflags & (1 << KEY_FLAG_REVOKED))
+            key_task_permission(make_key_ref(key, ctx->possessed),
-                        goto error_2;
+                                ctx->cred, KEY_SEARCH) < 0) {
-                if (key->expiry && now.tv_sec >= key->expiry)
+                ctx->result = ERR_PTR(-EACCES);
-                        goto error_2;
+                kleave(" = %d [!perm]", ctx->skipped_ret);
-                key_ref = ERR_PTR(key->type_data.reject_error);
+                goto skipped;
-                if (kflags & (1 << KEY_FLAG_NEGATIVE))
-                        goto error_2;
-                goto found;
        }
-        /* otherwise, the top keyring must not be revoked, expired, or
+        if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) {
-         * negatively instantiated if we are to search it */
+                /* we set a different error code if we pass a negative key */
-        key_ref = ERR_PTR(-EAGAIN);
+                if (kflags & (1 << KEY_FLAG_NEGATIVE)) {
-        if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
+                        smp_rmb();
-                      (1 << KEY_FLAG_REVOKED) |
+                        ctx->result = ERR_PTR(key->type_data.reject_error);
-                      (1 << KEY_FLAG_NEGATIVE)) ||
+                        kleave(" = %d [neg]", ctx->skipped_ret);
-            (keyring->expiry && now.tv_sec >= keyring->expiry))
+                        goto skipped;
-                goto error_2;
+                }
+        }
-        /* start processing a new keyring */
-descend:
-        kflags = keyring->flags;
-        if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
-                      (1 << KEY_FLAG_REVOKED)))
-                goto not_this_keyring;
-        keylist = rcu_dereference(keyring->payload.subscriptions);
+        /* Found */
-        if (!keylist)
+        ctx->result = make_key_ref(key, ctx->possessed);
-                goto not_this_keyring;
+        kleave(" = 1 [found]");
+        return 1;
-        /* iterate through the keys in this keyring first */
+skipped:
-        nkeys = keylist->nkeys;
+        return ctx->skipped_ret;
-        smp_rmb();
+}
-        for (kix = 0; kix < nkeys; kix++) {
-                key = rcu_dereference(keylist->keys[kix]);
-                kflags = key->flags;
-                /* ignore keys not of this type */
+/*
-                if (key->type != type)
+ * Search inside a keyring for a key.  We can search by walking to it
-                        continue;
+ * directly based on its index-key or we can iterate over the entire
+ * tree looking for it, based on the match function.
+ */
+static int search_keyring(struct key *keyring, struct keyring_search_context *ctx)
+{
+        if ((ctx->flags & KEYRING_SEARCH_LOOKUP_TYPE) ==
+            KEYRING_SEARCH_LOOKUP_DIRECT) {
+                const void *object;
+                object = assoc_array_find(&keyring->keys,
+                                          &keyring_assoc_array_ops,
+                                          &ctx->index_key);
+                return object ? ctx->iterator(object, ctx) : 0;
+        }
+        return assoc_array_iterate(&keyring->keys, ctx->iterator, ctx);
+}
-                /* skip invalidated, revoked and expired keys */
+/*
-                if (!no_state_check) {
+ * Search a tree of keyrings that point to other keyrings up to the maximum
-                        if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
+ * depth.
-                                      (1 << KEY_FLAG_REVOKED)))
+ */
-                                continue;
+static bool search_nested_keyrings(struct key *keyring,
+                                   struct keyring_search_context *ctx)
+{
+        struct {
+                struct key *keyring;
+                struct assoc_array_node *node;
+                int slot;
+        } stack[KEYRING_SEARCH_MAX_DEPTH];
-                        if (key->expiry && now.tv_sec >= key->expiry)
+        struct assoc_array_shortcut *shortcut;
-                                continue;
+        struct assoc_array_node *node;
-                }
+        struct assoc_array_ptr *ptr;
+        struct key *key;
+        int sp = 0, slot;
-                /* keys that don't match */
+        kenter("{%d},{%s,%s}",
-                if (!match(key, description))
+               keyring->serial,
-                        continue;
+               ctx->index_key.type->name,
+               ctx->index_key.description);
-                /* key must have search permissions */
+        if (ctx->index_key.description)
-                if (key_task_permission(make_key_ref(key, possessed),
+                ctx->index_key.desc_len = strlen(ctx->index_key.description);
-                                        cred, KEY_SEARCH) < 0)
-                        continue;
-                if (no_state_check)
+        /* Check to see if this top-level keyring is what we are looking for
+         * and whether it is valid or not.
+         */
+        if (ctx->flags & KEYRING_SEARCH_LOOKUP_ITERATE ||
+            keyring_compare_object(keyring, &ctx->index_key)) {
+                ctx->skipped_ret = 2;
+                ctx->flags |= KEYRING_SEARCH_DO_STATE_CHECK;
+                switch (ctx->iterator(keyring_key_to_ptr(keyring), ctx)) {
+                case 1:
                        goto found;
+                case 2:
-                /* we set a different error code if we pass a negative key */
+                        return false;
-                if (kflags & (1 << KEY_FLAG_NEGATIVE)) {
+                default:
-                        err = key->type_data.reject_error;
+                        break;
-                        continue;
                }
+        }
+        ctx->skipped_ret = 0;
+        if (ctx->flags & KEYRING_SEARCH_NO_STATE_CHECK)
+                ctx->flags &= ~KEYRING_SEARCH_DO_STATE_CHECK;
+        /* Start processing a new keyring */
+descend_to_keyring:
+        kdebug("descend to %d", keyring->serial);
+        if (keyring->flags & ((1 << KEY_FLAG_INVALIDATED) |
+                              (1 << KEY_FLAG_REVOKED)))
+                goto not_this_keyring;
+        /* Search through the keys in this keyring before its searching its
+         * subtrees.
+         */
+        if (search_keyring(keyring, ctx))
                goto found;
-        }
-        /* search through the keyrings nested in this one */
+        /* Then manually iterate through the keyrings nested in this one.
-        kix = 0;
+         *
-ascend:
+         * Start from the root node of the index tree.  Because of the way the
-        nkeys = keylist->nkeys;
+         * hash function has been set up, keyrings cluster on the leftmost
-        smp_rmb();
+         * branch of the root node (root slot 0) or in the root node itself.
-        for (; kix < nkeys; kix++) {
+         * Non-keyrings avoid the leftmost branch of the root entirely (root
-                key = rcu_dereference(keylist->keys[kix]);
+         * slots 1-15).
-                if (key->type != &key_type_keyring)
+         */
-                        continue;
+        ptr = ACCESS_ONCE(keyring->keys.root);
+        if (!ptr)
+                goto not_this_keyring;
-                /* recursively search nested keyrings
+        if (assoc_array_ptr_is_shortcut(ptr)) {
-                 * - only search keyrings for which we have search permission
+                /* If the root is a shortcut, either the keyring only contains
+                 * keyring pointers (everything clusters behind root slot 0) or
+                 * doesn't contain any keyring pointers.
                 */
-                if (sp >= KEYRING_SEARCH_MAX_DEPTH)
+                shortcut = assoc_array_ptr_to_shortcut(ptr);
+                smp_read_barrier_depends();
+                if ((shortcut->index_key[0] & ASSOC_ARRAY_FAN_MASK) != 0)
+                        goto not_this_keyring;
+                ptr = ACCESS_ONCE(shortcut->next_node);
+                node = assoc_array_ptr_to_node(ptr);
+                goto begin_node;
+        }
+        node = assoc_array_ptr_to_node(ptr);
+        smp_read_barrier_depends();
+        ptr = node->slots[0];
+        if (!assoc_array_ptr_is_meta(ptr))
+                goto begin_node;
+descend_to_node:
+        /* Descend to a more distal node in this keyring's content tree and go
+         * through that.
+         */
+        kdebug("descend");
+        if (assoc_array_ptr_is_shortcut(ptr)) {
+                shortcut = assoc_array_ptr_to_shortcut(ptr);
+                smp_read_barrier_depends();
+                ptr = ACCESS_ONCE(shortcut->next_node);
+                BUG_ON(!assoc_array_ptr_is_node(ptr));
+                node = assoc_array_ptr_to_node(ptr);
+        }
+begin_node:
+        kdebug("begin_node");
+        smp_read_barrier_depends();
+        slot = 0;
+ascend_to_node:
+        /* Go through the slots in a node */
+        for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) {
+                ptr = ACCESS_ONCE(node->slots[slot]);
+                if (assoc_array_ptr_is_meta(ptr) && node->back_pointer)
+                        goto descend_to_node;
+                if (!keyring_ptr_is_keyring(ptr))
                        continue;
-                if (key_task_permission(make_key_ref(key, possessed),
+                key = keyring_ptr_to_key(ptr);
-                                        cred, KEY_SEARCH) < 0)
+                if (sp >= KEYRING_SEARCH_MAX_DEPTH) {
+                        if (ctx->flags & KEYRING_SEARCH_DETECT_TOO_DEEP) {
+                                ctx->result = ERR_PTR(-ELOOP);
+                                return false;
+                        }
+                        goto not_this_keyring;
+                }
+                /* Search a nested keyring */
+                if (!(ctx->flags & KEYRING_SEARCH_NO_CHECK_PERM) &&
+                    key_task_permission(make_key_ref(key, ctx->possessed),
+                                        ctx->cred, KEY_SEARCH) < 0)
                        continue;
                /* stack the current position */
                stack[sp].keyring = keyring;
-                stack[sp].keylist = keylist;
+                stack[sp].node = node;
-                stack[sp].kix = kix;
+                stack[sp].slot = slot;
                sp++;
                /* begin again with the new keyring */
                keyring = key;
-                goto descend;
+                goto descend_to_keyring;
        }
-        /* the keyring we're looking at was disqualified or didn't contain a
+        /* We've dealt with all the slots in the current node, so now we need
-         * matching key */
+         * to ascend to the parent and continue processing there.
+         */
+        ptr = ACCESS_ONCE(node->back_pointer);
+        slot = node->parent_slot;
+        if (ptr && assoc_array_ptr_is_shortcut(ptr)) {
+                shortcut = assoc_array_ptr_to_shortcut(ptr);
+                smp_read_barrier_depends();
+                ptr = ACCESS_ONCE(shortcut->back_pointer);
+                slot = shortcut->parent_slot;
+        }
+        if (!ptr)
+                goto not_this_keyring;
+        node = assoc_array_ptr_to_node(ptr);
+        smp_read_barrier_depends();
+        slot++;
+        /* If we've ascended to the root (zero backpointer), we must have just
+         * finished processing the leftmost branch rather than the root slots -
+         * so there can't be any more keyrings for us to find.
+         */
+        if (node->back_pointer) {
+                kdebug("ascend %d", slot);
+                goto ascend_to_node;
+        }
+        /* The keyring we're looking at was disqualified or didn't contain a
+         * matching key.
+         */
 not_this_keyring:
-        if (sp > 0) {
+        kdebug("not_this_keyring %d", sp);
-                /* resume the processing of a keyring higher up in the tree */
+        if (sp <= 0) {
-                sp--;
+                kleave(" = false");
-                keyring = stack[sp].keyring;
+                return false;
-                keylist = stack[sp].keylist;
-                kix = stack[sp].kix + 1;
-                goto ascend;
        }
-        key_ref = ERR_PTR(err);
+        /* Resume the processing of a keyring higher up in the tree */
-        goto error_2;
+        sp--;
+        keyring = stack[sp].keyring;
+        node = stack[sp].node;
+        slot = stack[sp].slot + 1;
+        kdebug("ascend to %d [%d]", keyring->serial, slot);
+        goto ascend_to_node;
-        /* we found a viable match */
+        /* We found a viable match */
 found:
-        atomic_inc(&key->usage);
+        key = key_ref_to_ptr(ctx->result);
-        key->last_used_at = now.tv_sec;
-        keyring->last_used_at = now.tv_sec;
-        while (sp > 0)
-                stack[--sp].keyring->last_used_at = now.tv_sec;
        key_check(key);
-        key_ref = make_key_ref(key, possessed);
+        if (!(ctx->flags & KEYRING_SEARCH_NO_UPDATE_TIME)) {
-error_2:
+                key->last_used_at = ctx->now.tv_sec;
+                keyring->last_used_at = ctx->now.tv_sec;
+                while (sp > 0)
+                        stack[--sp].keyring->last_used_at = ctx->now.tv_sec;
+        }
+        kleave(" = true");
+        return true;
+}
+/**
+ * keyring_search_aux - Search a keyring tree for a key matching some criteria
+ * @keyring_ref: A pointer to the keyring with possession indicator.
+ * @ctx: The keyring search context.
+ *
+ * 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 can be 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,
+                             struct keyring_search_context *ctx)
+{
+        struct key *keyring;
+        long err;
+        ctx->iterator = keyring_search_iterator;
+        ctx->possessed = is_key_possessed(keyring_ref);
+        ctx->result = ERR_PTR(-EAGAIN);
+        keyring = key_ref_to_ptr(keyring_ref);
+        key_check(keyring);
+        if (keyring->type != &key_type_keyring)
+                return ERR_PTR(-ENOTDIR);
+        if (!(ctx->flags & KEYRING_SEARCH_NO_CHECK_PERM)) {
+                err = key_task_permission(keyring_ref, ctx->cred, KEY_SEARCH);
+                if (err < 0)
+                        return ERR_PTR(err);
+        }
+        rcu_read_lock();
+        ctx->now = current_kernel_time();
+        if (search_nested_keyrings(keyring, ctx))
+                __key_get(key_ref_to_ptr(ctx->result));
        rcu_read_unlock();
-error:
+        return ctx->result;
-        return key_ref;
 }
 /**
@@ -507,77 +864,73 @@ error:
 * @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.
+ * type's default matching function and preferred search method.
 */
 key_ref_t keyring_search(key_ref_t keyring,
                         struct key_type *type,
                         const char *description)
 {
-        if (!type->match)
+        struct keyring_search_context ctx = {
+                .index_key.type         = type,
+                .index_key.description  = description,
+                .cred                   = current_cred(),
+                .match                  = type->match,
+                .match_data             = description,
+                .flags                  = (type->def_lookup_type |
+                                           KEYRING_SEARCH_DO_STATE_CHECK),
+        };
+        if (!ctx.match)
                return ERR_PTR(-ENOKEY);
-        return keyring_search_aux(keyring, current->cred,
+        return keyring_search_aux(keyring, &ctx);
-                                  type, description, type->match, false);
 }
 EXPORT_SYMBOL(keyring_search);
 /*
- * Search the given keyring only (no recursion).
+ * Search the given keyring for a key that might be updated.
 *
 * 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.
+ * permission is granted to modify the keyring as no check is made here.  The
- *
+ * caller must also hold a lock on the keyring semaphore.
- * 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
+ * successful and returns NULL if not found.  Revoked and invalidated keys are
- * providing the requested permission are skipped over.
+ * 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,
+key_ref_t find_key_to_update(key_ref_t keyring_ref,
-                               const struct key_type *ktype,
+                             const struct keyring_index_key *index_key)
-                               const char *description,
-                               key_perm_t perm)
 {
-        struct keyring_list *klist;
-        unsigned long possessed;
        struct key *keyring, *key;
-        int nkeys, loop;
+        const void *object;
        keyring = key_ref_to_ptr(keyring_ref);
-        possessed = is_key_possessed(keyring_ref);
-        rcu_read_lock();
+        kenter("{%d},{%s,%s}",
+               keyring->serial, index_key->type->name, index_key->description);
-        klist = rcu_dereference(keyring->payload.subscriptions);
+        object = assoc_array_find(&keyring->keys, &keyring_assoc_array_ops,
-        if (klist) {
+                                  index_key);
-                nkeys = klist->nkeys;
-                smp_rmb();
-                for (loop = 0; loop < nkeys ; loop++) {
-                        key = rcu_dereference(klist->keys[loop]);
-                        if (key->type == ktype &&
-                            (!key->type->match ||
-                             key->type->match(key, description)) &&
-                            key_permission(make_key_ref(key, possessed),
-                                           perm) == 0 &&
-                            !(key->flags & ((1 << KEY_FLAG_INVALIDATED) |
-                                            (1 << KEY_FLAG_REVOKED)))
-                            )
-                                goto found;
-                }
-        }
-        rcu_read_unlock();
+        if (object)
-        return ERR_PTR(-ENOKEY);
+                goto found;
+        kleave(" = NULL");
+        return NULL;
 found:
-        atomic_inc(&key->usage);
+        key = keyring_ptr_to_key(object);
-        keyring->last_used_at = key->last_used_at =
+        if (key->flags & ((1 << KEY_FLAG_INVALIDATED) |
-                current_kernel_time().tv_sec;
+                          (1 << KEY_FLAG_REVOKED))) {
-        rcu_read_unlock();
+                kleave(" = NULL [x]");
-        return make_key_ref(key, possessed);
+                return NULL;
+        }
+        __key_get(key);
+        kleave(" = {%d}", key->serial);
+        return make_key_ref(key, is_key_possessed(keyring_ref));
 }
 /*
@@ -640,6 +993,19 @@ out:
        return keyring;
 }
+static int keyring_detect_cycle_iterator(const void *object,
+                                         void *iterator_data)
+{
+        struct keyring_search_context *ctx = iterator_data;
+        const struct key *key = keyring_ptr_to_key(object);
+        kenter("{%d}", key->serial);
+        BUG_ON(key != ctx->match_data);
+        ctx->result = ERR_PTR(-EDEADLK);
+        return 1;
+}
 /*
 * 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).
@@ -649,116 +1015,39 @@ out:
 */
 static int keyring_detect_cycle(struct key *A, struct key *B)
 {
-        struct {
+        struct keyring_search_context ctx = {
-                struct keyring_list *keylist;
+                .index_key      = A->index_key,
-                int kix;
+                .match_data     = A,
-        } stack[KEYRING_SEARCH_MAX_DEPTH];
+                .iterator       = keyring_detect_cycle_iterator,
+                .flags          = (KEYRING_SEARCH_LOOKUP_DIRECT |
-        struct keyring_list *keylist;
+                                   KEYRING_SEARCH_NO_STATE_CHECK |
-        struct key *subtree, *key;
+                                   KEYRING_SEARCH_NO_UPDATE_TIME |
-        int sp, nkeys, kix, ret;
+                                   KEYRING_SEARCH_NO_CHECK_PERM |
+                                   KEYRING_SEARCH_DETECT_TOO_DEEP),
+        };
        rcu_read_lock();
+        search_nested_keyrings(B, &ctx);
-        ret = -EDEADLK;
-        if (A == B)
-                goto cycle_detected;
-        subtree = B;
-        sp = 0;
-        /* start processing a new keyring */
-descend:
-        if (test_bit(KEY_FLAG_REVOKED, &subtree->flags))
-                goto not_this_keyring;
-        keylist = rcu_dereference(subtree->payload.subscriptions);
-        if (!keylist)
-                goto not_this_keyring;
-        kix = 0;
-ascend:
-        /* iterate through the remaining keys in this keyring */
-        nkeys = keylist->nkeys;
-        smp_rmb();
-        for (; kix < nkeys; kix++) {
-                key = rcu_dereference(keylist->keys[kix]);
-                if (key == A)
-                        goto cycle_detected;
-                /* recursively check nested keyrings */
-                if (key->type == &key_type_keyring) {
-                        if (sp >= KEYRING_SEARCH_MAX_DEPTH)
-                                goto too_deep;
-                        /* stack the current position */
-                        stack[sp].keylist = keylist;
-                        stack[sp].kix = kix;
-                        sp++;
-                        /* begin again with the new keyring */
-                        subtree = key;
-                        goto descend;
-                }
-        }
-        /* the keyring we're looking at was disqualified or didn't contain a
-         * matching key */
-not_this_keyring:
-        if (sp > 0) {
-                /* resume the checking of a keyring higher up in the tree */
-                sp--;
-                keylist = stack[sp].keylist;
-                kix = stack[sp].kix + 1;
-                goto ascend;
-        }
-        ret = 0; /* no cycles detected */
-error:
        rcu_read_unlock();
-        return ret;
+        return PTR_ERR(ctx.result) == -EAGAIN ? 0 : PTR_ERR(ctx.result);
-too_deep:
-        ret = -ELOOP;
-        goto error;
-cycle_detected:
-        ret = -EDEADLK;
-        goto error;
-}
-/*
- * Dispose of a keyring list after the RCU grace period, freeing the unlinked
- * key
- */
-static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
-{
-        struct keyring_list *klist =
-                container_of(rcu, struct keyring_list, rcu);
-        if (klist->delkey != USHRT_MAX)
-                key_put(rcu_access_pointer(klist->keys[klist->delkey]));
-        kfree(klist);
 }
 /*
 * 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,
+int __key_link_begin(struct key *keyring,
-                     const char *description, unsigned long *_prealloc)
+                     const struct keyring_index_key *index_key,
+                     struct assoc_array_edit **_edit)
        __acquires(&keyring->sem)
        __acquires(&keyring_serialise_link_sem)
 {
-        struct keyring_list *klist, *nklist;
+        struct assoc_array_edit *edit;
-        unsigned long prealloc;
+        int ret;
-        unsigned max;
-        time_t lowest_lru;
+        kenter("%d,%s,%s,",
-        size_t size;
+               keyring->serial, index_key->type->name, index_key->description);
-        int loop, lru, ret;
-        kenter("%d,%s,%s,", key_serial(keyring), type->name, description);
+        BUG_ON(index_key->desc_len == 0);
        if (keyring->type != &key_type_keyring)
                return -ENOTDIR;
@@ -771,100 +1060,39 @@ int __key_link_begin(struct key *keyring, const struct key_type *type,
        /* serialise link/link calls to prevent parallel calls causing a cycle
         * when linking two keyring in opposite orders */
-        if (type == &key_type_keyring)
+        if (index_key->type == &key_type_keyring)
                down_write(&keyring_serialise_link_sem);
-        klist = rcu_dereference_locked_keyring(keyring);
+        /* Create an edit script that will insert/replace the key in the
+         * keyring tree.
-        /* see if there's a matching key we can displace */
+         */
-        lru = -1;
+        edit = assoc_array_insert(&keyring->keys,
-        if (klist && klist->nkeys > 0) {
+                                  &keyring_assoc_array_ops,
-                lowest_lru = TIME_T_MAX;
+                                  index_key,
-                for (loop = klist->nkeys - 1; loop >= 0; loop--) {
+                                  NULL);
-                        struct key *key = rcu_deref_link_locked(klist, loop,
+        if (IS_ERR(edit)) {
-                                                                keyring);
+                ret = PTR_ERR(edit);
-                        if (key->type == type &&
-                            strcmp(key->description, description) == 0) {
-                                /* Found a match - we'll replace the link with
-                                 * one to the new key.  We record the slot
-                                 * position.
-                                 */
-                                klist->delkey = loop;
-                                prealloc = 0;
-                                goto done;
-                        }
-                        if (key->last_used_at < lowest_lru) {
-                                lowest_lru = key->last_used_at;
-                                lru = loop;
-                        }
-                }
-        }
-        /* If the keyring is full then do an LRU discard */
-        if (klist &&
-            klist->nkeys == klist->maxkeys &&
-            klist->maxkeys >= MAX_KEYRING_LINKS) {
-                kdebug("LRU discard %d\n", lru);
-                klist->delkey = lru;
-                prealloc = 0;
-                goto done;
-        }
-        /* check that we aren't going to overrun the user's quota */
-        ret = key_payload_reserve(keyring,
-                                  keyring->datalen + KEYQUOTA_LINK_BYTES);
-        if (ret < 0)
                goto error_sem;
+        }
-        if (klist && klist->nkeys < klist->maxkeys) {
+        /* If we're not replacing a link in-place then we're going to need some
-                /* there's sufficient slack space to append directly */
+         * extra quota.
-                klist->delkey = klist->nkeys;
+         */
-                prealloc = KEY_LINK_FIXQUOTA;
+        if (!edit->dead_leaf) {
-        } else {
+                ret = key_payload_reserve(keyring,
-                /* grow the key list */
+                                          keyring->datalen + KEYQUOTA_LINK_BYTES);
-                max = 4;
+                if (ret < 0)
-                if (klist) {
+                        goto error_cancel;
-                        max += klist->maxkeys;
-                        if (max > MAX_KEYRING_LINKS)
-                                max = MAX_KEYRING_LINKS;
-                        BUG_ON(max <= klist->maxkeys);
-                }
-                size = sizeof(*klist) + sizeof(struct key *) * max;
-                ret = -ENOMEM;
-                nklist = kmalloc(size, GFP_KERNEL);
-                if (!nklist)
-                        goto error_quota;
-                nklist->maxkeys = max;
-                if (klist) {
-                        memcpy(nklist->keys, klist->keys,
-                               sizeof(struct key *) * klist->nkeys);
-                        nklist->delkey = klist->nkeys;
-                        nklist->nkeys = klist->nkeys + 1;
-                        klist->delkey = USHRT_MAX;
-                } else {
-                        nklist->nkeys = 1;
-                        nklist->delkey = 0;
-                }
-                /* add the key into the new space */
-                RCU_INIT_POINTER(nklist->keys[nklist->delkey], NULL);
-                prealloc = (unsigned long)nklist | KEY_LINK_FIXQUOTA;
        }
-done:
+        *_edit = edit;
-        *_prealloc = prealloc;
        kleave(" = 0");
        return 0;
-error_quota:
+error_cancel:
-        /* undo the quota changes */
+        assoc_array_cancel_edit(edit);
-        key_payload_reserve(keyring,
-                            keyring->datalen - KEYQUOTA_LINK_BYTES);
 error_sem:
-        if (type == &key_type_keyring)
+        if (index_key->type == &key_type_keyring)
                up_write(&keyring_serialise_link_sem);
 error_krsem:
        up_write(&keyring->sem);
@@ -895,60 +1123,12 @@ int __key_link_check_live_key(struct key *keyring, struct key *key)
 * holds at most one link to any given key of a particular type+description
 * combination.
 */
-void __key_link(struct key *keyring, struct key *key,
+void __key_link(struct key *key, struct assoc_array_edit **_edit)
-                unsigned long *_prealloc)
 {
-        struct keyring_list *klist, *nklist;
+        __key_get(key);
-        struct key *discard;
+        assoc_array_insert_set_object(*_edit, keyring_key_to_ptr(key));
+        assoc_array_apply_edit(*_edit);
-        nklist = (struct keyring_list *)(*_prealloc & ~KEY_LINK_FIXQUOTA);
+        *_edit = NULL;
-        *_prealloc = 0;
-        kenter("%d,%d,%p", keyring->serial, key->serial, nklist);
-        klist = rcu_dereference_locked_keyring(keyring);
-        atomic_inc(&key->usage);
-        keyring->last_used_at = key->last_used_at =
-                current_kernel_time().tv_sec;
-        /* there's a matching key we can displace or an empty slot in a newly
-         * allocated list we can fill */
-        if (nklist) {
-                kdebug("reissue %hu/%hu/%hu",
-                       nklist->delkey, nklist->nkeys, nklist->maxkeys);
-                RCU_INIT_POINTER(nklist->keys[nklist->delkey], key);
-                rcu_assign_pointer(keyring->payload.subscriptions, nklist);
-                /* dispose of the old keyring list and, if there was one, the
-                 * displaced key */
-                if (klist) {
-                        kdebug("dispose %hu/%hu/%hu",
-                               klist->delkey, klist->nkeys, klist->maxkeys);
-                        call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
-                }
-        } else if (klist->delkey < klist->nkeys) {
-                kdebug("replace %hu/%hu/%hu",
-                       klist->delkey, klist->nkeys, klist->maxkeys);
-                discard = rcu_dereference_protected(
-                        klist->keys[klist->delkey],
-                        rwsem_is_locked(&keyring->sem));
-                rcu_assign_pointer(klist->keys[klist->delkey], key);
-                /* The garbage collector will take care of RCU
-                 * synchronisation */
-                key_put(discard);
-        } else {
-                /* there's sufficient slack space to append directly */
-                kdebug("append %hu/%hu/%hu",
-                       klist->delkey, klist->nkeys, klist->maxkeys);
-                RCU_INIT_POINTER(klist->keys[klist->delkey], key);
-                smp_wmb();
-                klist->nkeys++;
-        }
 }
 /*
@@ -956,24 +1136,22 @@ void __key_link(struct key *keyring, struct key *key,
 *
 * Must be called with __key_link_begin() having being called.
 */
-void __key_link_end(struct key *keyring, struct key_type *type,
+void __key_link_end(struct key *keyring,
-                    unsigned long prealloc)
+                    const struct keyring_index_key *index_key,
+                    struct assoc_array_edit *edit)
        __releases(&keyring->sem)
        __releases(&keyring_serialise_link_sem)
 {
-        BUG_ON(type == NULL);
+        BUG_ON(index_key->type == NULL);
-        BUG_ON(type->name == NULL);
+        kenter("%d,%s,", keyring->serial, index_key->type->name);
-        kenter("%d,%s,%lx", keyring->serial, type->name, prealloc);
-        if (type == &key_type_keyring)
+        if (index_key->type == &key_type_keyring)
                up_write(&keyring_serialise_link_sem);
-        if (prealloc) {
+        if (edit && !edit->dead_leaf) {
-                if (prealloc & KEY_LINK_FIXQUOTA)
+                key_payload_reserve(keyring,
-                        key_payload_reserve(keyring,
+                                    keyring->datalen - KEYQUOTA_LINK_BYTES);
-                                            keyring->datalen -
+                assoc_array_cancel_edit(edit);
-                                            KEYQUOTA_LINK_BYTES);
-                kfree((struct keyring_list *)(prealloc & ~KEY_LINK_FIXQUOTA));
        }
        up_write(&keyring->sem);
 }
@@ -1000,20 +1178,28 @@ void __key_link_end(struct key *keyring, struct key_type *type,
 */
 int key_link(struct key *keyring, struct key *key)
 {
-        unsigned long prealloc;
+        struct assoc_array_edit *edit;
        int ret;
+        kenter("{%d,%d}", keyring->serial, atomic_read(&keyring->usage));
        key_check(keyring);
        key_check(key);
-        ret = __key_link_begin(keyring, key->type, key->description, &prealloc);
+        if (test_bit(KEY_FLAG_TRUSTED_ONLY, &keyring->flags) &&
+            !test_bit(KEY_FLAG_TRUSTED, &key->flags))
+                return -EPERM;
+        ret = __key_link_begin(keyring, &key->index_key, &edit);
        if (ret == 0) {
+                kdebug("begun {%d,%d}", keyring->serial, atomic_read(&keyring->usage));
                ret = __key_link_check_live_key(keyring, key);
                if (ret == 0)
-                        __key_link(keyring, key, &prealloc);
+                        __key_link(key, &edit);
-                __key_link_end(keyring, key->type, prealloc);
+                __key_link_end(keyring, &key->index_key, edit);
        }
+        kleave(" = %d {%d,%d}", ret, keyring->serial, atomic_read(&keyring->usage));
        return ret;
 }
 EXPORT_SYMBOL(key_link);
@@ -1037,90 +1223,37 @@ EXPORT_SYMBOL(key_link);
 */
 int key_unlink(struct key *keyring, struct key *key)
 {
-        struct keyring_list *klist, *nklist;
+        struct assoc_array_edit *edit;
-        int loop, ret;
+        int ret;
        key_check(keyring);
        key_check(key);
-        ret = -ENOTDIR;
        if (keyring->type != &key_type_keyring)
-                goto error;
+                return -ENOTDIR;
        down_write(&keyring->sem);
-        klist = rcu_dereference_locked_keyring(keyring);
+        edit = assoc_array_delete(&keyring->keys, &keyring_assoc_array_ops,
-        if (klist) {
+                                  &key->index_key);
-                /* search the keyring for the key */
+        if (IS_ERR(edit)) {
-                for (loop = 0; loop < klist->nkeys; loop++)
+                ret = PTR_ERR(edit);
-                        if (rcu_access_pointer(klist->keys[loop]) == key)
+                goto error;
-                                goto key_is_present;
        }
-        up_write(&keyring->sem);
        ret = -ENOENT;
-        goto error;
+        if (edit == NULL)
+                goto error;
-key_is_present:
-        /* we need to copy the key list for RCU purposes */
-        nklist = kmalloc(sizeof(*klist) +
-                         sizeof(struct key *) * klist->maxkeys,
-                         GFP_KERNEL);
-        if (!nklist)
-                goto nomem;
-        nklist->maxkeys = klist->maxkeys;
-        nklist->nkeys = klist->nkeys - 1;
-        if (loop > 0)
-                memcpy(&nklist->keys[0],
-                       &klist->keys[0],
-                       loop * sizeof(struct key *));
-        if (loop < nklist->nkeys)
-                memcpy(&nklist->keys[loop],
-                       &klist->keys[loop + 1],
-                       (nklist->nkeys - loop) * sizeof(struct key *));
-        /* adjust the user's quota */
-        key_payload_reserve(keyring,
-                            keyring->datalen - KEYQUOTA_LINK_BYTES);
-        rcu_assign_pointer(keyring->payload.subscriptions, nklist);
-        up_write(&keyring->sem);
-        /* schedule for later cleanup */
-        klist->delkey = loop;
-        call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
+        assoc_array_apply_edit(edit);
+        key_payload_reserve(keyring, keyring->datalen - KEYQUOTA_LINK_BYTES);
        ret = 0;
 error:
-        return ret;
-nomem:
-        ret = -ENOMEM;
        up_write(&keyring->sem);
-        goto error;
+        return ret;
 }
 EXPORT_SYMBOL(key_unlink);
-/*
- * 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)
-{
-        struct keyring_list *klist;
-        int loop;
-        klist = container_of(rcu, struct keyring_list, rcu);
-        for (loop = klist->nkeys - 1; loop >= 0; loop--)
-                key_put(rcu_access_pointer(klist->keys[loop]));
-        kfree(klist);
-}
 /**
 * keyring_clear - Clear a keyring
 * @keyring: The keyring to clear.
@@ -1131,33 +1264,25 @@ static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
 */
 int keyring_clear(struct key *keyring)
 {
-        struct keyring_list *klist;
+        struct assoc_array_edit *edit;
        int ret;
-        ret = -ENOTDIR;
+        if (keyring->type != &key_type_keyring)
-        if (keyring->type == &key_type_keyring) {
+                return -ENOTDIR;
-                /* detach the pointer block with the locks held */
-                down_write(&keyring->sem);
-                klist = rcu_dereference_locked_keyring(keyring);
-                if (klist) {
-                        /* adjust the quota */
-                        key_payload_reserve(keyring,
-                                            sizeof(struct keyring_list));
-                        rcu_assign_pointer(keyring->payload.subscriptions,
-                                           NULL);
-                }
-                up_write(&keyring->sem);
-                /* free the keys after the locks have been dropped */
+        down_write(&keyring->sem);
-                if (klist)
-                        call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
+        edit = assoc_array_clear(&keyring->keys, &keyring_assoc_array_ops);
+        if (IS_ERR(edit)) {
+                ret = PTR_ERR(edit);
+        } else {
+                if (edit)
+                        assoc_array_apply_edit(edit);
+                key_payload_reserve(keyring, 0);
                ret = 0;
        }
+        up_write(&keyring->sem);
        return ret;
 }
 EXPORT_SYMBOL(keyring_clear);
@@ -1169,111 +1294,68 @@ EXPORT_SYMBOL(keyring_clear);
 */
 static void keyring_revoke(struct key *keyring)
 {
-        struct keyring_list *klist;
+        struct assoc_array_edit *edit;
+        edit = assoc_array_clear(&keyring->keys, &keyring_assoc_array_ops);
+        if (!IS_ERR(edit)) {
+                if (edit)
+                        assoc_array_apply_edit(edit);
+                key_payload_reserve(keyring, 0);
+        }
+}
+static bool keyring_gc_select_iterator(void *object, void *iterator_data)
+{
+        struct key *key = keyring_ptr_to_key(object);
+        time_t *limit = iterator_data;
-        klist = rcu_dereference_locked_keyring(keyring);
+        if (key_is_dead(key, *limit))
+                return false;
+        key_get(key);
+        return true;
+}
-        /* adjust the quota */
+static int keyring_gc_check_iterator(const void *object, void *iterator_data)
-        key_payload_reserve(keyring, 0);
+{
+        const struct key *key = keyring_ptr_to_key(object);
+        time_t *limit = iterator_data;
-        if (klist) {
+        key_check(key);
-                rcu_assign_pointer(keyring->payload.subscriptions, NULL);
+        return key_is_dead(key, *limit);
-                call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
-        }
 }
 /*
- * Collect garbage from the contents of a keyring, replacing the old list with
+ * Garbage collect pointers from a keyring.
- * a new one with the pointers all shuffled down.
 *
- * Dead keys are classed as oned that are flagged as being dead or are revoked,
+ * Not called with any locks held.  The keyring's key struct will not be
- * expired or negative keys that were revoked or expired before the specified
+ * deallocated under us as only our caller may deallocate it.
- * limit.
 */
 void keyring_gc(struct key *keyring, time_t limit)
 {
-        struct keyring_list *klist, *new;
+        int result;
-        struct key *key;
-        int loop, keep, max;
-        kenter("{%x,%s}", key_serial(keyring), keyring->description);
-        down_write(&keyring->sem);
-        klist = rcu_dereference_locked_keyring(keyring);
-        if (!klist)
-                goto no_klist;
-        /* work out how many subscriptions we're keeping */
-        keep = 0;
-        for (loop = klist->nkeys - 1; loop >= 0; loop--)
-                if (!key_is_dead(rcu_deref_link_locked(klist, loop, keyring),
-                                 limit))
-                        keep++;
-        if (keep == klist->nkeys)
-                goto just_return;
-        /* allocate a new keyring payload */
-        max = roundup(keep, 4);
-        new = kmalloc(sizeof(struct keyring_list) + max * sizeof(struct key *),
-                      GFP_KERNEL);
-        if (!new)
-                goto nomem;
-        new->maxkeys = max;
-        new->nkeys = 0;
-        new->delkey = 0;
-        /* install the live keys
-         * - must take care as expired keys may be updated back to life
-         */
-        keep = 0;
-        for (loop = klist->nkeys - 1; loop >= 0; loop--) {
-                key = rcu_deref_link_locked(klist, loop, keyring);
-                if (!key_is_dead(key, limit)) {
-                        if (keep >= max)
-                                goto discard_new;
-                        RCU_INIT_POINTER(new->keys[keep++], key_get(key));
-                }
-        }
-        new->nkeys = keep;
-        /* adjust the quota */
-        key_payload_reserve(keyring,
-                            sizeof(struct keyring_list) +
-                            KEYQUOTA_LINK_BYTES * keep);
-        if (keep == 0) {
+        kenter("%x{%s}", keyring->serial, keyring->description ?: "");
-                rcu_assign_pointer(keyring->payload.subscriptions, NULL);
-                kfree(new);
-        } else {
-                rcu_assign_pointer(keyring->payload.subscriptions, new);
-        }
-        up_write(&keyring->sem);
+        if (keyring->flags & ((1 << KEY_FLAG_INVALIDATED) |
+                              (1 << KEY_FLAG_REVOKED)))
+                goto dont_gc;
-        call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
+        /* scan the keyring looking for dead keys */
-        kleave(" [yes]");
+        rcu_read_lock();
-        return;
+        result = assoc_array_iterate(&keyring->keys,
+                                     keyring_gc_check_iterator, &limit);
-discard_new:
+        rcu_read_unlock();
-        new->nkeys = keep;
+        if (result == true)
-        keyring_clear_rcu_disposal(&new->rcu);
+                goto do_gc;
-        up_write(&keyring->sem);
-        kleave(" [discard]");
-        return;
-just_return:
-        up_write(&keyring->sem);
-        kleave(" [no dead]");
-        return;
-no_klist:
+dont_gc:
-        up_write(&keyring->sem);
+        kleave(" [no gc]");
-        kleave(" [no_klist]");
        return;
-nomem:
+do_gc:
+        down_write(&keyring->sem);
+        assoc_array_gc(&keyring->keys, &keyring_assoc_array_ops,
+                       keyring_gc_select_iterator, &limit);
        up_write(&keyring->sem);
-        kleave(" [oom]");
+        kleave(" [gc]");
 }
diff --git a/security/keys/persistent.c b/security/keys/persistent.c
new file mode 100644
index 000000000000..0ad3ee283781
--- /dev/null
+++ b/security/keys/persistent.c
@@ -0,0 +1,167 @@
+/* General persistent per-UID keyrings register
+ *
+ * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+#include <linux/user_namespace.h>
+#include "internal.h"
+unsigned persistent_keyring_expiry = 3 * 24 * 3600; /* Expire after 3 days of non-use */
+/*
+ * Create the persistent keyring register for the current user namespace.
+ *
+ * Called with the namespace's sem locked for writing.
+ */
+static int key_create_persistent_register(struct user_namespace *ns)
+{
+        struct key *reg = keyring_alloc(".persistent_register",
+                                        KUIDT_INIT(0), KGIDT_INIT(0),
+                                        current_cred(),
+                                        ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
+                                         KEY_USR_VIEW | KEY_USR_READ),
+                                        KEY_ALLOC_NOT_IN_QUOTA, NULL);
+        if (IS_ERR(reg))
+                return PTR_ERR(reg);
+        ns->persistent_keyring_register = reg;
+        return 0;
+}
+/*
+ * Create the persistent keyring for the specified user.
+ *
+ * Called with the namespace's sem locked for writing.
+ */
+static key_ref_t key_create_persistent(struct user_namespace *ns, kuid_t uid,
+                                       struct keyring_index_key *index_key)
+{
+        struct key *persistent;
+        key_ref_t reg_ref, persistent_ref;
+        if (!ns->persistent_keyring_register) {
+                long err = key_create_persistent_register(ns);
+                if (err < 0)
+                        return ERR_PTR(err);
+        } else {
+                reg_ref = make_key_ref(ns->persistent_keyring_register, true);
+                persistent_ref = find_key_to_update(reg_ref, index_key);
+                if (persistent_ref)
+                        return persistent_ref;
+        }
+        persistent = keyring_alloc(index_key->description,
+                                   uid, INVALID_GID, current_cred(),
+                                   ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
+                                    KEY_USR_VIEW | KEY_USR_READ),
+                                   KEY_ALLOC_NOT_IN_QUOTA,
+                                   ns->persistent_keyring_register);
+        if (IS_ERR(persistent))
+                return ERR_CAST(persistent);
+        return make_key_ref(persistent, true);
+}
+/*
+ * Get the persistent keyring for a specific UID and link it to the nominated
+ * keyring.
+ */
+static long key_get_persistent(struct user_namespace *ns, kuid_t uid,
+                               key_ref_t dest_ref)
+{
+        struct keyring_index_key index_key;
+        struct key *persistent;
+        key_ref_t reg_ref, persistent_ref;
+        char buf[32];
+        long ret;
+        /* Look in the register if it exists */
+        index_key.type = &key_type_keyring;
+        index_key.description = buf;
+        index_key.desc_len = sprintf(buf, "_persistent.%u", from_kuid(ns, uid));
+        if (ns->persistent_keyring_register) {
+                reg_ref = make_key_ref(ns->persistent_keyring_register, true);
+                down_read(&ns->persistent_keyring_register_sem);
+                persistent_ref = find_key_to_update(reg_ref, &index_key);
+                up_read(&ns->persistent_keyring_register_sem);
+                if (persistent_ref)
+                        goto found;
+        }
+        /* It wasn't in the register, so we'll need to create it.  We might
+         * also need to create the register.
+         */
+        down_write(&ns->persistent_keyring_register_sem);
+        persistent_ref = key_create_persistent(ns, uid, &index_key);
+        up_write(&ns->persistent_keyring_register_sem);
+        if (!IS_ERR(persistent_ref))
+                goto found;
+        return PTR_ERR(persistent_ref);
+found:
+        ret = key_task_permission(persistent_ref, current_cred(), KEY_LINK);
+        if (ret == 0) {
+                persistent = key_ref_to_ptr(persistent_ref);
+                ret = key_link(key_ref_to_ptr(dest_ref), persistent);
+                if (ret == 0) {
+                        key_set_timeout(persistent, persistent_keyring_expiry);
+                        ret = persistent->serial;               
+                }
+        }
+        key_ref_put(persistent_ref);
+        return ret;
+}
+/*
+ * Get the persistent keyring for a specific UID and link it to the nominated
+ * keyring.
+ */
+long keyctl_get_persistent(uid_t _uid, key_serial_t destid)
+{
+        struct user_namespace *ns = current_user_ns();
+        key_ref_t dest_ref;
+        kuid_t uid;
+        long ret;
+        /* -1 indicates the current user */
+        if (_uid == (uid_t)-1) {
+                uid = current_uid();
+        } else {
+                uid = make_kuid(ns, _uid);
+                if (!uid_valid(uid))
+                        return -EINVAL;
+                /* You can only see your own persistent cache if you're not
+                 * sufficiently privileged.
+                 */
+                if (!uid_eq(uid, current_uid()) &&
+                    !uid_eq(uid, current_euid()) &&
+                    !ns_capable(ns, CAP_SETUID))
+                        return -EPERM;
+        }
+        /* There must be a destination keyring */
+        dest_ref = lookup_user_key(destid, KEY_LOOKUP_CREATE, KEY_WRITE);
+        if (IS_ERR(dest_ref))
+                return PTR_ERR(dest_ref);
+        if (key_ref_to_ptr(dest_ref)->type != &key_type_keyring) {
+                ret = -ENOTDIR;
+                goto out_put_dest;
+        }
+        ret = key_get_persistent(ns, uid, dest_ref);
+out_put_dest:
+        key_ref_put(dest_ref);
+        return ret;
+}
diff --git a/security/keys/proc.c b/security/keys/proc.c
index 217b6855e815..88e9a466940f 100644
--- a/security/keys/proc.c
+++ b/security/keys/proc.c
@@ -182,7 +182,6 @@ static void proc_keys_stop(struct seq_file *p, void *v)
 static int proc_keys_show(struct seq_file *m, void *v)
 {
-        const struct cred *cred = current_cred();
        struct rb_node *_p = v;
        struct key *key = rb_entry(_p, struct key, serial_node);
        struct timespec now;
@@ -191,15 +190,23 @@ static int proc_keys_show(struct seq_file *m, void *v)
        char xbuf[12];
        int rc;
+        struct keyring_search_context ctx = {
+                .index_key.type         = key->type,
+                .index_key.description  = key->description,
+                .cred                   = current_cred(),
+                .match                  = lookup_user_key_possessed,
+                .match_data             = key,
+                .flags                  = (KEYRING_SEARCH_NO_STATE_CHECK |
+                                           KEYRING_SEARCH_LOOKUP_DIRECT),
+        };
        key_ref = make_key_ref(key, 0);
        /* determine if the key is possessed by this process (a test we can
         * skip if the key does not indicate the possessor can view it
         */
        if (key->perm & KEY_POS_VIEW) {
-                skey_ref = search_my_process_keyrings(key->type, key,
+                skey_ref = search_my_process_keyrings(&ctx);
-                                                      lookup_user_key_possessed,
-                                                      true, cred);
                if (!IS_ERR(skey_ref)) {
                        key_ref_put(skey_ref);
                        key_ref = make_key_ref(key, 1);
@@ -211,7 +218,7 @@ static int proc_keys_show(struct seq_file *m, void *v)
         * - the caller holds a spinlock, and thus the RCU read lock, making our
         *   access to __current_cred() safe
         */
-        rc = key_task_permission(key_ref, cred, KEY_VIEW);
+        rc = key_task_permission(key_ref, ctx.cred, KEY_VIEW);
        if (rc < 0)
                return 0;
diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c
index 42defae1e161..0cf8a130a267 100644
--- a/security/keys/process_keys.c
+++ b/security/keys/process_keys.c
@@ -235,7 +235,7 @@ int install_session_keyring_to_cred(struct cred *cred, struct key *keyring)
                if (IS_ERR(keyring))
                        return PTR_ERR(keyring);
        } else {
-                atomic_inc(&keyring->usage);
+                __key_get(keyring);
        }
        /* install the keyring */
@@ -319,11 +319,7 @@ void key_fsgid_changed(struct task_struct *tsk)
 * 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,
+key_ref_t search_my_process_keyrings(struct keyring_search_context *ctx)
-                                     const void *description,
-                                     key_match_func_t match,
-                                     bool no_state_check,
-                                     const struct cred *cred)
 {
        key_ref_t key_ref, ret, err;
@@ -339,10 +335,9 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
        err = ERR_PTR(-EAGAIN);
        /* search the thread keyring first */
-        if (cred->thread_keyring) {
+        if (ctx->cred->thread_keyring) {
                key_ref = keyring_search_aux(
-                        make_key_ref(cred->thread_keyring, 1),
+                        make_key_ref(ctx->cred->thread_keyring, 1), ctx);
-                        cred, type, description, match, no_state_check);
                if (!IS_ERR(key_ref))
                        goto found;
@@ -358,10 +353,9 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
        }
        /* search the process keyring second */
-        if (cred->process_keyring) {
+        if (ctx->cred->process_keyring) {
                key_ref = keyring_search_aux(
-                        make_key_ref(cred->process_keyring, 1),
+                        make_key_ref(ctx->cred->process_keyring, 1), ctx);
-                        cred, type, description, match, no_state_check);
                if (!IS_ERR(key_ref))
                        goto found;
@@ -379,11 +373,11 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
        }
        /* search the session keyring */
-        if (cred->session_keyring) {
+        if (ctx->cred->session_keyring) {
                rcu_read_lock();
                key_ref = keyring_search_aux(
-                        make_key_ref(rcu_dereference(cred->session_keyring), 1),
+                        make_key_ref(rcu_dereference(ctx->cred->session_keyring), 1),
-                        cred, type, description, match, no_state_check);
+                        ctx);
                rcu_read_unlock();
                if (!IS_ERR(key_ref))
@@ -402,10 +396,10 @@ key_ref_t search_my_process_keyrings(struct key_type *type,
                }
        }
        /* or search the user-session keyring */
-        else if (cred->user->session_keyring) {
+        else if (ctx->cred->user->session_keyring) {
                key_ref = keyring_search_aux(
-                        make_key_ref(cred->user->session_keyring, 1),
+                        make_key_ref(ctx->cred->user->session_keyring, 1),
-                        cred, type, description, match, no_state_check);
+                        ctx);
                if (!IS_ERR(key_ref))
                        goto found;
@@ -437,18 +431,14 @@ found:
 *
 * Return same as search_my_process_keyrings().
 */
-key_ref_t search_process_keyrings(struct key_type *type,
+key_ref_t search_process_keyrings(struct keyring_search_context *ctx)
-                                  const void *description,
-                                  key_match_func_t match,
-                                  const struct cred *cred)
 {
        struct request_key_auth *rka;
        key_ref_t key_ref, ret = ERR_PTR(-EACCES), err;
        might_sleep();
-        key_ref = search_my_process_keyrings(type, description, match,
+        key_ref = search_my_process_keyrings(ctx);
-                                             false, cred);
        if (!IS_ERR(key_ref))
                goto found;
        err = key_ref;
@@ -457,18 +447,21 @@ key_ref_t search_process_keyrings(struct key_type *type,
         * search the keyrings of the process mentioned there
         * - we don't permit access to request_key auth keys via this method
         */
-        if (cred->request_key_auth &&
+        if (ctx->cred->request_key_auth &&
-            cred == current_cred() &&
+            ctx->cred == current_cred() &&
-            type != &key_type_request_key_auth
+            ctx->index_key.type != &key_type_request_key_auth
            ) {
+                const struct cred *cred = ctx->cred;
                /* defend against the auth key being revoked */
                down_read(&cred->request_key_auth->sem);
-                if (key_validate(cred->request_key_auth) == 0) {
+                if (key_validate(ctx->cred->request_key_auth) == 0) {
-                        rka = cred->request_key_auth->payload.data;
+                        rka = ctx->cred->request_key_auth->payload.data;
-                        key_ref = search_process_keyrings(type, description,
+                        ctx->cred = rka->cred;
-                                                          match, rka->cred);
+                        key_ref = search_process_keyrings(ctx);
+                        ctx->cred = cred;
                        up_read(&cred->request_key_auth->sem);
@@ -522,19 +515,23 @@ int lookup_user_key_possessed(const struct key *key, const void *target)
 key_ref_t lookup_user_key(key_serial_t id, unsigned long lflags,
                          key_perm_t perm)
 {
+        struct keyring_search_context ctx = {
+                .match  = lookup_user_key_possessed,
+                .flags  = (KEYRING_SEARCH_NO_STATE_CHECK |
+                           KEYRING_SEARCH_LOOKUP_DIRECT),
+        };
        struct request_key_auth *rka;
-        const struct cred *cred;
        struct key *key;
        key_ref_t key_ref, skey_ref;
        int ret;
 try_again:
-        cred = get_current_cred();
+        ctx.cred = get_current_cred();
        key_ref = ERR_PTR(-ENOKEY);
        switch (id) {
        case KEY_SPEC_THREAD_KEYRING:
-                if (!cred->thread_keyring) {
+                if (!ctx.cred->thread_keyring) {
                        if (!(lflags & KEY_LOOKUP_CREATE))
                                goto error;
@@ -546,13 +543,13 @@ try_again:
                        goto reget_creds;
                }
-                key = cred->thread_keyring;
+                key = ctx.cred->thread_keyring;
-                atomic_inc(&key->usage);
+                __key_get(key);
                key_ref = make_key_ref(key, 1);
                break;
        case KEY_SPEC_PROCESS_KEYRING:
-                if (!cred->process_keyring) {
+                if (!ctx.cred->process_keyring) {
                        if (!(lflags & KEY_LOOKUP_CREATE))
                                goto error;
@@ -564,13 +561,13 @@ try_again:
                        goto reget_creds;
                }
-                key = cred->process_keyring;
+                key = ctx.cred->process_keyring;
-                atomic_inc(&key->usage);
+                __key_get(key);
                key_ref = make_key_ref(key, 1);
                break;
        case KEY_SPEC_SESSION_KEYRING:
-                if (!cred->session_keyring) {
+                if (!ctx.cred->session_keyring) {
                        /* always install a session keyring upon access if one
                         * doesn't exist yet */
                        ret = install_user_keyrings();
@@ -580,13 +577,13 @@ try_again:
                                ret = join_session_keyring(NULL);
                        else
                                ret = install_session_keyring(
-                                        cred->user->session_keyring);
+                                        ctx.cred->user->session_keyring);
                        if (ret < 0)
                                goto error;
                        goto reget_creds;
-                } else if (cred->session_keyring ==
+                } else if (ctx.cred->session_keyring ==
-                           cred->user->session_keyring &&
+                           ctx.cred->user->session_keyring &&
                           lflags & KEY_LOOKUP_CREATE) {
                        ret = join_session_keyring(NULL);
                        if (ret < 0)
@@ -595,33 +592,33 @@ try_again:
                }
                rcu_read_lock();
-                key = rcu_dereference(cred->session_keyring);
+                key = rcu_dereference(ctx.cred->session_keyring);
-                atomic_inc(&key->usage);
+                __key_get(key);
                rcu_read_unlock();
                key_ref = make_key_ref(key, 1);
                break;
        case KEY_SPEC_USER_KEYRING:
-                if (!cred->user->uid_keyring) {
+                if (!ctx.cred->user->uid_keyring) {
                        ret = install_user_keyrings();
                        if (ret < 0)
                                goto error;
                }
-                key = cred->user->uid_keyring;
+                key = ctx.cred->user->uid_keyring;
-                atomic_inc(&key->usage);
+                __key_get(key);
                key_ref = make_key_ref(key, 1);
                break;
        case KEY_SPEC_USER_SESSION_KEYRING:
-                if (!cred->user->session_keyring) {
+                if (!ctx.cred->user->session_keyring) {
                        ret = install_user_keyrings();
                        if (ret < 0)
                                goto error;
                }
-                key = cred->user->session_keyring;
+                key = ctx.cred->user->session_keyring;
-                atomic_inc(&key->usage);
+                __key_get(key);
                key_ref = make_key_ref(key, 1);
                break;
@@ -631,29 +628,29 @@ try_again:
                goto error;
        case KEY_SPEC_REQKEY_AUTH_KEY:
-                key = cred->request_key_auth;
+                key = ctx.cred->request_key_auth;
                if (!key)
                        goto error;
-                atomic_inc(&key->usage);
+                __key_get(key);
                key_ref = make_key_ref(key, 1);
                break;
        case KEY_SPEC_REQUESTOR_KEYRING:
-                if (!cred->request_key_auth)
+                if (!ctx.cred->request_key_auth)
                        goto error;
-                down_read(&cred->request_key_auth->sem);
+                down_read(&ctx.cred->request_key_auth->sem);
                if (test_bit(KEY_FLAG_REVOKED,
-                             &cred->request_key_auth->flags)) {
+                             &ctx.cred->request_key_auth->flags)) {
                        key_ref = ERR_PTR(-EKEYREVOKED);
                        key = NULL;
                } else {
-                        rka = cred->request_key_auth->payload.data;
+                        rka = ctx.cred->request_key_auth->payload.data;
                        key = rka->dest_keyring;
-                        atomic_inc(&key->usage);
+                        __key_get(key);
                }
-                up_read(&cred->request_key_auth->sem);
+                up_read(&ctx.cred->request_key_auth->sem);
                if (!key)
                        goto error;
                key_ref = make_key_ref(key, 1);
@@ -673,9 +670,13 @@ try_again:
                key_ref = make_key_ref(key, 0);
                /* check to see if we possess the key */
-                skey_ref = search_process_keyrings(key->type, key,
+                ctx.index_key.type              = key->type;
-                                                   lookup_user_key_possessed,
+                ctx.index_key.description       = key->description;
-                                                   cred);
+                ctx.index_key.desc_len          = strlen(key->description);
+                ctx.match_data                  = key;
+                kdebug("check possessed");
+                skey_ref = search_process_keyrings(&ctx);
+                kdebug("possessed=%p", skey_ref);
                if (!IS_ERR(skey_ref)) {
                        key_put(key);
@@ -715,14 +716,14 @@ try_again:
                goto invalid_key;
        /* check the permissions */
-        ret = key_task_permission(key_ref, cred, perm);
+        ret = key_task_permission(key_ref, ctx.cred, perm);
        if (ret < 0)
                goto invalid_key;
        key->last_used_at = current_kernel_time().tv_sec;
 error:
-        put_cred(cred);
+        put_cred(ctx.cred);
        return key_ref;
 invalid_key:
@@ -733,7 +734,7 @@ invalid_key:
        /* if we attempted to install a keyring, then it may have caused new
         * creds to be installed */
 reget_creds:
-        put_cred(cred);
+        put_cred(ctx.cred);
        goto try_again;
 }
@@ -856,3 +857,13 @@ void key_change_session_keyring(struct callback_head *twork)
        commit_creds(new);
 }
+/*
+ * Make sure that root's user and user-session keyrings exist.
+ */
+static int __init init_root_keyring(void)
+{
+        return install_user_keyrings();
+}
+late_initcall(init_root_keyring);
diff --git a/security/keys/request_key.c b/security/keys/request_key.c
index c411f9bb156b..381411941cc1 100644
--- a/security/keys/request_key.c
+++ b/security/keys/request_key.c
@@ -345,33 +345,34 @@ static void construct_get_dest_keyring(struct key **_dest_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,
+static int construct_alloc_key(struct keyring_search_context *ctx,
-                               const char *description,
                               struct key *dest_keyring,
                               unsigned long flags,
                               struct key_user *user,
                               struct key **_key)
 {
-        const struct cred *cred = current_cred();
+        struct assoc_array_edit *edit;
-        unsigned long prealloc;
        struct key *key;
        key_perm_t perm;
        key_ref_t key_ref;
        int ret;
-        kenter("%s,%s,,,", type->name, description);
+        kenter("%s,%s,,,",
+               ctx->index_key.type->name, ctx->index_key.description);
        *_key = NULL;
        mutex_lock(&user->cons_lock);
        perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
        perm |= KEY_USR_VIEW;
-        if (type->read)
+        if (ctx->index_key.type->read)
                perm |= KEY_POS_READ;
-        if (type == &key_type_keyring || type->update)
+        if (ctx->index_key.type == &key_type_keyring ||
+            ctx->index_key.type->update)
                perm |= KEY_POS_WRITE;
-        key = key_alloc(type, description, cred->fsuid, cred->fsgid, cred,
+        key = key_alloc(ctx->index_key.type, ctx->index_key.description,
+                        ctx->cred->fsuid, ctx->cred->fsgid, ctx->cred,
                        perm, flags);
        if (IS_ERR(key))
                goto alloc_failed;
@@ -379,8 +380,7 @@ static int construct_alloc_key(struct key_type *type,
        set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
        if (dest_keyring) {
-                ret = __key_link_begin(dest_keyring, type, description,
+                ret = __key_link_begin(dest_keyring, &ctx->index_key, &edit);
-                                       &prealloc);
                if (ret < 0)
                        goto link_prealloc_failed;
        }
@@ -390,16 +390,16 @@ static int construct_alloc_key(struct key_type *type,
         * waited for locks */
        mutex_lock(&key_construction_mutex);
-        key_ref = search_process_keyrings(type, description, type->match, cred);
+        key_ref = search_process_keyrings(ctx);
        if (!IS_ERR(key_ref))
                goto key_already_present;
        if (dest_keyring)
-                __key_link(dest_keyring, key, &prealloc);
+                __key_link(key, &edit);
        mutex_unlock(&key_construction_mutex);
        if (dest_keyring)
-                __key_link_end(dest_keyring, type, prealloc);
+                __key_link_end(dest_keyring, &ctx->index_key, edit);
        mutex_unlock(&user->cons_lock);
        *_key = key;
        kleave(" = 0 [%d]", key_serial(key));
@@ -414,8 +414,8 @@ key_already_present:
        if (dest_keyring) {
                ret = __key_link_check_live_key(dest_keyring, key);
                if (ret == 0)
-                        __key_link(dest_keyring, key, &prealloc);
+                        __key_link(key, &edit);
-                __key_link_end(dest_keyring, type, prealloc);
+                __key_link_end(dest_keyring, &ctx->index_key, edit);
                if (ret < 0)
                        goto link_check_failed;
        }
@@ -444,8 +444,7 @@ alloc_failed:
 /*
 * Commence key construction.
 */
-static struct key *construct_key_and_link(struct key_type *type,
+static struct key *construct_key_and_link(struct keyring_search_context *ctx,
-                                          const char *description,
                                          const char *callout_info,
                                          size_t callout_len,
                                          void *aux,
@@ -464,8 +463,7 @@ static struct key *construct_key_and_link(struct key_type *type,
        construct_get_dest_keyring(&dest_keyring);
-        ret = construct_alloc_key(type, description, dest_keyring, flags, user,
+        ret = construct_alloc_key(ctx, dest_keyring, flags, user, &key);
-                                  &key);
        key_user_put(user);
        if (ret == 0) {
@@ -529,17 +527,24 @@ struct key *request_key_and_link(struct key_type *type,
                                 struct key *dest_keyring,
                                 unsigned long flags)
 {
-        const struct cred *cred = current_cred();
+        struct keyring_search_context ctx = {
+                .index_key.type         = type,
+                .index_key.description  = description,
+                .cred                   = current_cred(),
+                .match                  = type->match,
+                .match_data             = description,
+                .flags                  = KEYRING_SEARCH_LOOKUP_DIRECT,
+        };
        struct key *key;
        key_ref_t key_ref;
        int ret;
        kenter("%s,%s,%p,%zu,%p,%p,%lx",
-               type->name, description, callout_info, callout_len, aux,
+               ctx.index_key.type->name, ctx.index_key.description,
-               dest_keyring, flags);
+               callout_info, callout_len, aux, 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(&ctx);
        if (!IS_ERR(key_ref)) {
                key = key_ref_to_ptr(key_ref);
@@ -562,9 +567,8 @@ struct key *request_key_and_link(struct key_type *type,
                if (!callout_info)
                        goto error;
-                key = construct_key_and_link(type, description, callout_info,
+                key = construct_key_and_link(&ctx, callout_info, callout_len,
-                                             callout_len, aux, dest_keyring,
+                                             aux, dest_keyring, flags);
-                                             flags);
        }
 error:
@@ -592,8 +596,10 @@ int wait_for_key_construction(struct key *key, bool intr)
                          intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
        if (ret < 0)
                return ret;
-        if (test_bit(KEY_FLAG_NEGATIVE, &key->flags))
+        if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) {
+                smp_rmb();
                return key->type_data.reject_error;
+        }
        return key_validate(key);
 }
 EXPORT_SYMBOL(wait_for_key_construction);
diff --git a/security/keys/request_key_auth.c b/security/keys/request_key_auth.c
index 85730d5a5a59..7495a93b4b90 100644
--- a/security/keys/request_key_auth.c
+++ b/security/keys/request_key_auth.c
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 #include <asm/uaccess.h>
 #include "internal.h"
+#include <keys/user-type.h>
 static int request_key_auth_instantiate(struct key *,
                                        struct key_preparsed_payload *);
@@ -222,32 +223,26 @@ error_alloc:
 }
 /*
- * 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)
-{
-        struct request_key_auth *rka = key->payload.data;
-        key_serial_t id = (key_serial_t)(unsigned long) _id;
-        return rka->target_key->serial == id;
-}
-/*
 * 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)
 {
-        const struct cred *cred = current_cred();
+        char description[16];
+        struct keyring_search_context ctx = {
+                .index_key.type         = &key_type_request_key_auth,
+                .index_key.description  = description,
+                .cred                   = current_cred(),
+                .match                  = user_match,
+                .match_data             = description,
+                .flags                  = KEYRING_SEARCH_LOOKUP_DIRECT,
+        };
        struct key *authkey;
        key_ref_t authkey_ref;
-        authkey_ref = search_process_keyrings(
+        sprintf(description, "%x", target_id);
-                &key_type_request_key_auth,
-                (void *) (unsigned long) target_id,
+        authkey_ref = search_process_keyrings(&ctx);
-                key_get_instantiation_authkey_match,
-                cred);
        if (IS_ERR(authkey_ref)) {
                authkey = ERR_CAST(authkey_ref);
diff --git a/security/keys/sysctl.c b/security/keys/sysctl.c
index ee32d181764a..8c0af08760c8 100644
--- a/security/keys/sysctl.c
+++ b/security/keys/sysctl.c
@@ -61,5 +61,16 @@ ctl_table key_sysctls[] = {
                .extra1 = (void *) &zero,
                .extra2 = (void *) &max,
        },
+#ifdef CONFIG_PERSISTENT_KEYRINGS
+        {
+                .procname = "persistent_keyring_expiry",
+                .data = &persistent_keyring_expiry,
+                .maxlen = sizeof(unsigned),
+                .mode = 0644,
+                .proc_handler = proc_dointvec_minmax,
+                .extra1 = (void *) &zero,
+                .extra2 = (void *) &max,
+        },
+#endif
        { }
 };
diff --git a/security/keys/user_defined.c b/security/keys/user_defined.c
index 55dc88939185..faa2caeb593f 100644
--- a/security/keys/user_defined.c
+++ b/security/keys/user_defined.c
@@ -25,14 +25,15 @@ static int logon_vet_description(const char *desc);
 * arbitrary blob of data as the payload
 */
 struct key_type key_type_user = {
-        .name           = "user",
+        .name                   = "user",
-        .instantiate    = user_instantiate,
+        .def_lookup_type        = KEYRING_SEARCH_LOOKUP_DIRECT,
-        .update         = user_update,
+        .instantiate            = user_instantiate,
-        .match          = user_match,
+        .update                 = user_update,
-        .revoke         = user_revoke,
+        .match                  = user_match,
-        .destroy        = user_destroy,
+        .revoke                 = user_revoke,
-        .describe       = user_describe,
+        .destroy                = user_destroy,
-        .read           = user_read,
+        .describe               = user_describe,
+        .read                   = user_read,
 };
 EXPORT_SYMBOL_GPL(key_type_user);
@@ -45,6 +46,7 @@ EXPORT_SYMBOL_GPL(key_type_user);
 */
 struct key_type key_type_logon = {
        .name                   = "logon",
+        .def_lookup_type        = KEYRING_SEARCH_LOOKUP_DIRECT,
        .instantiate            = user_instantiate,
        .update                 = user_update,
        .match                  = user_match,
diff --git a/security/security.c b/security/security.c
index 4dc31f4f2700..15b6928592ef 100644
--- a/security/security.c
+++ b/security/security.c
@@ -1340,22 +1340,17 @@ int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
        return security_ops->xfrm_policy_delete_security(ctx);
 }
-int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx)
+int security_xfrm_state_alloc(struct xfrm_state *x,
+                              struct xfrm_user_sec_ctx *sec_ctx)
 {
-        return security_ops->xfrm_state_alloc_security(x, sec_ctx, 0);
+        return security_ops->xfrm_state_alloc(x, sec_ctx);
 }
 EXPORT_SYMBOL(security_xfrm_state_alloc);
 int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
                                      struct xfrm_sec_ctx *polsec, u32 secid)
 {
-        if (!polsec)
+        return security_ops->xfrm_state_alloc_acquire(x, polsec, secid);
-                return 0;
-        /*
-         * We want the context to be taken from secid which is usually
-         * from the sock.
-         */
-        return security_ops->xfrm_state_alloc_security(x, NULL, secid);
 }
 int security_xfrm_state_delete(struct xfrm_state *x)
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index c540795fb3f2..794c3ca49eac 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -95,7 +95,9 @@
 #include "audit.h"
 #include "avc_ss.h"
-#define NUM_SEL_MNT_OPTS 5
+#define SB_TYPE_FMT "%s%s%s"
+#define SB_SUBTYPE(sb) (sb->s_subtype && sb->s_subtype[0])
+#define SB_TYPE_ARGS(sb) sb->s_type->name, SB_SUBTYPE(sb) ? "." : "", SB_SUBTYPE(sb) ? sb->s_subtype : ""
 extern struct security_operations *security_ops;
@@ -139,12 +141,28 @@ static struct kmem_cache *sel_inode_cache;
 * This function checks the SECMARK reference counter to see if any SECMARK
 * targets are currently configured, if the reference counter is greater than
 * zero SECMARK is considered to be enabled.  Returns true (1) if SECMARK is
- * enabled, false (0) if SECMARK is disabled.
+ * enabled, false (0) if SECMARK is disabled.  If the always_check_network
+ * policy capability is enabled, SECMARK is always considered enabled.
 *
 */
 static int selinux_secmark_enabled(void)
 {
-        return (atomic_read(&selinux_secmark_refcount) > 0);
+        return (selinux_policycap_alwaysnetwork || atomic_read(&selinux_secmark_refcount));
+}
+/**
+ * selinux_peerlbl_enabled - Check to see if peer labeling is currently enabled
+ *
+ * Description:
+ * This function checks if NetLabel or labeled IPSEC is enabled.  Returns true
+ * (1) if any are enabled or false (0) if neither are enabled.  If the
+ * always_check_network policy capability is enabled, peer labeling
+ * is always considered enabled.
+ *
+ */
+static int selinux_peerlbl_enabled(void)
+{
+        return (selinux_policycap_alwaysnetwork || netlbl_enabled() || selinux_xfrm_enabled());
 }
 /*
@@ -309,8 +327,11 @@ enum {
        Opt_defcontext = 3,
        Opt_rootcontext = 4,
        Opt_labelsupport = 5,
+        Opt_nextmntopt = 6,
 };
+#define NUM_SEL_MNT_OPTS        (Opt_nextmntopt - 1)
 static const match_table_t tokens = {
        {Opt_context, CONTEXT_STR "%s"},
        {Opt_fscontext, FSCONTEXT_STR "%s"},
@@ -355,6 +376,29 @@ static int may_context_mount_inode_relabel(u32 sid,
        return rc;
 }
+static int selinux_is_sblabel_mnt(struct super_block *sb)
+{
+        struct superblock_security_struct *sbsec = sb->s_security;
+        if (sbsec->behavior == SECURITY_FS_USE_XATTR ||
+            sbsec->behavior == SECURITY_FS_USE_TRANS ||
+            sbsec->behavior == SECURITY_FS_USE_TASK)
+                return 1;
+        /* Special handling for sysfs. Is genfs but also has setxattr handler*/
+        if (strncmp(sb->s_type->name, "sysfs", sizeof("sysfs")) == 0)
+                return 1;
+        /*
+         * Special handling for rootfs. Is genfs but supports
+         * setting SELinux context on in-core inodes.
+         */
+        if (strncmp(sb->s_type->name, "rootfs", sizeof("rootfs")) == 0)
+                return 1;
+        return 0;
+}
 static int sb_finish_set_opts(struct super_block *sb)
 {
        struct superblock_security_struct *sbsec = sb->s_security;
@@ -369,8 +413,8 @@ static int sb_finish_set_opts(struct super_block *sb)
                   the first boot of the SELinux kernel before we have
                   assigned xattr values to the filesystem. */
                if (!root_inode->i_op->getxattr) {
-                        printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
+                        printk(KERN_WARNING "SELinux: (dev %s, type "SB_TYPE_FMT") has no "
-                               "xattr support\n", sb->s_id, sb->s_type->name);
+                               "xattr support\n", sb->s_id, SB_TYPE_ARGS(sb));
                        rc = -EOPNOTSUPP;
                        goto out;
                }
@@ -378,35 +422,27 @@ static int sb_finish_set_opts(struct super_block *sb)
                if (rc < 0 && rc != -ENODATA) {
                        if (rc == -EOPNOTSUPP)
                                printk(KERN_WARNING "SELinux: (dev %s, type "
-                                       "%s) has no security xattr handler\n",
+                                       SB_TYPE_FMT") has no security xattr handler\n",
-                                       sb->s_id, sb->s_type->name);
+                                       sb->s_id, SB_TYPE_ARGS(sb));
                        else
                                printk(KERN_WARNING "SELinux: (dev %s, type "
-                                       "%s) getxattr errno %d\n", sb->s_id,
+                                       SB_TYPE_FMT") getxattr errno %d\n", sb->s_id,
-                                       sb->s_type->name, -rc);
+                                       SB_TYPE_ARGS(sb), -rc);
                        goto out;
                }
        }
-        sbsec->flags |= (SE_SBINITIALIZED | SE_SBLABELSUPP);
        if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
-                printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
+                printk(KERN_ERR "SELinux: initialized (dev %s, type "SB_TYPE_FMT"), unknown behavior\n",
-                       sb->s_id, sb->s_type->name);
+                       sb->s_id, SB_TYPE_ARGS(sb));
        else
-                printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
+                printk(KERN_DEBUG "SELinux: initialized (dev %s, type "SB_TYPE_FMT"), %s\n",
-                       sb->s_id, sb->s_type->name,
+                       sb->s_id, SB_TYPE_ARGS(sb),
                       labeling_behaviors[sbsec->behavior-1]);
-        if (sbsec->behavior == SECURITY_FS_USE_GENFS ||
+        sbsec->flags |= SE_SBINITIALIZED;
-            sbsec->behavior == SECURITY_FS_USE_MNTPOINT ||
+        if (selinux_is_sblabel_mnt(sb))
-            sbsec->behavior == SECURITY_FS_USE_NONE ||
+                sbsec->flags |= SBLABEL_MNT;
-            sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
-                sbsec->flags &= ~SE_SBLABELSUPP;
-        /* Special handling for sysfs. Is genfs but also has setxattr handler*/
-        if (strncmp(sb->s_type->name, "sysfs", sizeof("sysfs")) == 0)
-                sbsec->flags |= SE_SBLABELSUPP;
        /* Initialize the root inode. */
        rc = inode_doinit_with_dentry(root_inode, root);
@@ -460,15 +496,18 @@ static int selinux_get_mnt_opts(const struct super_block *sb,
        if (!ss_initialized)
                return -EINVAL;
+        /* make sure we always check enough bits to cover the mask */
+        BUILD_BUG_ON(SE_MNTMASK >= (1 << NUM_SEL_MNT_OPTS));
        tmp = sbsec->flags & SE_MNTMASK;
        /* count the number of mount options for this sb */
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < NUM_SEL_MNT_OPTS; i++) {
                if (tmp & 0x01)
                        opts->num_mnt_opts++;
                tmp >>= 1;
        }
        /* Check if the Label support flag is set */
-        if (sbsec->flags & SE_SBLABELSUPP)
+        if (sbsec->flags & SBLABEL_MNT)
                opts->num_mnt_opts++;
        opts->mnt_opts = kcalloc(opts->num_mnt_opts, sizeof(char *), GFP_ATOMIC);
@@ -515,9 +554,9 @@ static int selinux_get_mnt_opts(const struct super_block *sb,
                opts->mnt_opts[i] = context;
                opts->mnt_opts_flags[i++] = ROOTCONTEXT_MNT;
        }
-        if (sbsec->flags & SE_SBLABELSUPP) {
+        if (sbsec->flags & SBLABEL_MNT) {
                opts->mnt_opts[i] = NULL;
-                opts->mnt_opts_flags[i++] = SE_SBLABELSUPP;
+                opts->mnt_opts_flags[i++] = SBLABEL_MNT;
        }
        BUG_ON(i != opts->num_mnt_opts);
@@ -561,7 +600,6 @@ static int selinux_set_mnt_opts(struct super_block *sb,
        const struct cred *cred = current_cred();
        int rc = 0, i;
        struct superblock_security_struct *sbsec = sb->s_security;
-        const char *name = sb->s_type->name;
        struct inode *inode = sbsec->sb->s_root->d_inode;
        struct inode_security_struct *root_isec = inode->i_security;
        u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
@@ -614,14 +652,14 @@ static int selinux_set_mnt_opts(struct super_block *sb,
        for (i = 0; i < num_opts; i++) {
                u32 sid;
-                if (flags[i] == SE_SBLABELSUPP)
+                if (flags[i] == SBLABEL_MNT)
                        continue;
                rc = security_context_to_sid(mount_options[i],
                                             strlen(mount_options[i]), &sid);
                if (rc) {
                        printk(KERN_WARNING "SELinux: security_context_to_sid"
-                               "(%s) failed for (dev %s, type %s) errno=%d\n",
+                               "(%s) failed for (dev %s, type "SB_TYPE_FMT") errno=%d\n",
-                               mount_options[i], sb->s_id, name, rc);
+                               mount_options[i], sb->s_id, SB_TYPE_ARGS(sb), rc);
                        goto out;
                }
                switch (flags[i]) {
@@ -685,9 +723,7 @@ static int selinux_set_mnt_opts(struct super_block *sb,
                 * Determine the labeling behavior to use for this
                 * filesystem type.
                 */
-                rc = security_fs_use((sbsec->flags & SE_SBPROC) ?
+                rc = security_fs_use(sb);
-                                        "proc" : sb->s_type->name,
-                                        &sbsec->behavior, &sbsec->sid);
                if (rc) {
                        printk(KERN_WARNING
                                "%s: security_fs_use(%s) returned %d\n",
@@ -770,7 +806,8 @@ out:
 out_double_mount:
        rc = -EINVAL;
        printk(KERN_WARNING "SELinux: mount invalid.  Same superblock, different "
-               "security settings for (dev %s, type %s)\n", sb->s_id, name);
+               "security settings for (dev %s, type "SB_TYPE_FMT")\n", sb->s_id,
+               SB_TYPE_ARGS(sb));
        goto out;
 }
@@ -1037,7 +1074,7 @@ static void selinux_write_opts(struct seq_file *m,
                case DEFCONTEXT_MNT:
                        prefix = DEFCONTEXT_STR;
                        break;
-                case SE_SBLABELSUPP:
+                case SBLABEL_MNT:
                        seq_putc(m, ',');
                        seq_puts(m, LABELSUPP_STR);
                        continue;
@@ -1649,7 +1686,7 @@ static int may_create(struct inode *dir,
        if (rc)
                return rc;
-        if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
+        if (!newsid || !(sbsec->flags & SBLABEL_MNT)) {
                rc = security_transition_sid(sid, dsec->sid, tclass,
                                             &dentry->d_name, &newsid);
                if (rc)
@@ -2437,14 +2474,14 @@ static int selinux_sb_remount(struct super_block *sb, void *data)
                u32 sid;
                size_t len;
-                if (flags[i] == SE_SBLABELSUPP)
+                if (flags[i] == SBLABEL_MNT)
                        continue;
                len = strlen(mount_options[i]);
                rc = security_context_to_sid(mount_options[i], len, &sid);
                if (rc) {
                        printk(KERN_WARNING "SELinux: security_context_to_sid"
-                               "(%s) failed for (dev %s, type %s) errno=%d\n",
+                               "(%s) failed for (dev %s, type "SB_TYPE_FMT") errno=%d\n",
-                               mount_options[i], sb->s_id, sb->s_type->name, rc);
+                               mount_options[i], sb->s_id, SB_TYPE_ARGS(sb), rc);
                        goto out_free_opts;
                }
                rc = -EINVAL;
@@ -2482,8 +2519,8 @@ out_free_secdata:
        return rc;
 out_bad_option:
        printk(KERN_WARNING "SELinux: unable to change security options "
-               "during remount (dev %s, type=%s)\n", sb->s_id,
+               "during remount (dev %s, type "SB_TYPE_FMT")\n", sb->s_id,
-               sb->s_type->name);
+               SB_TYPE_ARGS(sb));
        goto out_free_opts;
 }
@@ -2606,7 +2643,7 @@ static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
        if ((sbsec->flags & SE_SBINITIALIZED) &&
            (sbsec->behavior == SECURITY_FS_USE_MNTPOINT))
                newsid = sbsec->mntpoint_sid;
-        else if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
+        else if (!newsid || !(sbsec->flags & SBLABEL_MNT)) {
                rc = security_transition_sid(sid, dsec->sid,
                                             inode_mode_to_security_class(inode->i_mode),
                                             qstr, &newsid);
@@ -2628,7 +2665,7 @@ static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
                isec->initialized = 1;
        }
-        if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
+        if (!ss_initialized || !(sbsec->flags & SBLABEL_MNT))
                return -EOPNOTSUPP;
        if (name)
@@ -2830,7 +2867,7 @@ static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
                return selinux_inode_setotherxattr(dentry, name);
        sbsec = inode->i_sb->s_security;
-        if (!(sbsec->flags & SE_SBLABELSUPP))
+        if (!(sbsec->flags & SBLABEL_MNT))
                return -EOPNOTSUPP;
        if (!inode_owner_or_capable(inode))
@@ -3791,8 +3828,12 @@ static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid)
        u32 nlbl_sid;
        u32 nlbl_type;
-        selinux_skb_xfrm_sid(skb, &xfrm_sid);
+        err = selinux_skb_xfrm_sid(skb, &xfrm_sid);
-        selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
+        if (unlikely(err))
+                return -EACCES;
+        err = selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
+        if (unlikely(err))
+                return -EACCES;
        err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid);
        if (unlikely(err)) {
@@ -4246,7 +4287,7 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
                return selinux_sock_rcv_skb_compat(sk, skb, family);
        secmark_active = selinux_secmark_enabled();
-        peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
+        peerlbl_active = selinux_peerlbl_enabled();
        if (!secmark_active && !peerlbl_active)
                return 0;
@@ -4628,7 +4669,7 @@ static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
        secmark_active = selinux_secmark_enabled();
        netlbl_active = netlbl_enabled();
-        peerlbl_active = netlbl_active || selinux_xfrm_enabled();
+        peerlbl_active = selinux_peerlbl_enabled();
        if (!secmark_active && !peerlbl_active)
                return NF_ACCEPT;
@@ -4780,7 +4821,7 @@ static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
                return NF_ACCEPT;
 #endif
        secmark_active = selinux_secmark_enabled();
-        peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
+        peerlbl_active = selinux_peerlbl_enabled();
        if (!secmark_active && !peerlbl_active)
                return NF_ACCEPT;
@@ -5784,7 +5825,8 @@ static struct security_operations selinux_ops = {
        .xfrm_policy_clone_security =   selinux_xfrm_policy_clone,
        .xfrm_policy_free_security =    selinux_xfrm_policy_free,
        .xfrm_policy_delete_security =  selinux_xfrm_policy_delete,
-        .xfrm_state_alloc_security =    selinux_xfrm_state_alloc,
+        .xfrm_state_alloc =             selinux_xfrm_state_alloc,
+        .xfrm_state_alloc_acquire =     selinux_xfrm_state_alloc_acquire,
        .xfrm_state_free_security =     selinux_xfrm_state_free,
        .xfrm_state_delete_security =   selinux_xfrm_state_delete,
        .xfrm_policy_lookup =           selinux_xfrm_policy_lookup,
diff --git a/security/selinux/include/objsec.h b/security/selinux/include/objsec.h
index aa47bcabb5f6..b1dfe1049450 100644
--- a/security/selinux/include/objsec.h
+++ b/security/selinux/include/objsec.h
@@ -58,8 +58,8 @@ struct superblock_security_struct {
        u32 sid;                        /* SID of file system superblock */
        u32 def_sid;                    /* default SID for labeling */
        u32 mntpoint_sid;               /* SECURITY_FS_USE_MNTPOINT context for files */
-        unsigned int behavior;          /* labeling behavior */
+        unsigned short behavior;        /* labeling behavior */
-        unsigned char flags;            /* which mount options were specified */
+        unsigned short flags;           /* which mount options were specified */
        struct mutex lock;
        struct list_head isec_head;
        spinlock_t isec_lock;
diff --git a/security/selinux/include/security.h b/security/selinux/include/security.h
index 8fd8e18ea340..fe341ae37004 100644
--- a/security/selinux/include/security.h
+++ b/security/selinux/include/security.h
@@ -45,14 +45,15 @@
 /* Mask for just the mount related flags */
 #define SE_MNTMASK      0x0f
 /* Super block security struct flags for mount options */
+/* BE CAREFUL, these need to be the low order bits for selinux_get_mnt_opts */
 #define CONTEXT_MNT     0x01
 #define FSCONTEXT_MNT   0x02
 #define ROOTCONTEXT_MNT 0x04
 #define DEFCONTEXT_MNT  0x08
+#define SBLABEL_MNT     0x10
 /* Non-mount related flags */
-#define SE_SBINITIALIZED        0x10
+#define SE_SBINITIALIZED        0x0100
-#define SE_SBPROC               0x20
+#define SE_SBPROC               0x0200
-#define SE_SBLABELSUPP  0x40
 #define CONTEXT_STR     "context="
 #define FSCONTEXT_STR   "fscontext="
@@ -68,12 +69,15 @@ extern int selinux_enabled;
 enum {
        POLICYDB_CAPABILITY_NETPEER,
        POLICYDB_CAPABILITY_OPENPERM,
+        POLICYDB_CAPABILITY_REDHAT1,
+        POLICYDB_CAPABILITY_ALWAYSNETWORK,
        __POLICYDB_CAPABILITY_MAX
 };
 #define POLICYDB_CAPABILITY_MAX (__POLICYDB_CAPABILITY_MAX - 1)
 extern int selinux_policycap_netpeer;
 extern int selinux_policycap_openperm;
+extern int selinux_policycap_alwaysnetwork;
 /*
 * type_datum properties
@@ -172,8 +176,7 @@ int security_get_allow_unknown(void);
 #define SECURITY_FS_USE_NATIVE          7 /* use native label support */
 #define SECURITY_FS_USE_MAX             7 /* Highest SECURITY_FS_USE_XXX */
-int security_fs_use(const char *fstype, unsigned int *behavior,
+int security_fs_use(struct super_block *sb);
-        u32 *sid);
 int security_genfs_sid(const char *fstype, char *name, u16 sclass,
        u32 *sid);
diff --git a/security/selinux/include/xfrm.h b/security/selinux/include/xfrm.h
index 6713f04e30ba..0dec76c64cf5 100644
--- a/security/selinux/include/xfrm.h
+++ b/security/selinux/include/xfrm.h
@@ -10,29 +10,21 @@
 #include <net/flow.h>
 int selinux_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
-                              struct xfrm_user_sec_ctx *sec_ctx);
+                              struct xfrm_user_sec_ctx *uctx);
 int selinux_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx,
                              struct xfrm_sec_ctx **new_ctxp);
 void selinux_xfrm_policy_free(struct xfrm_sec_ctx *ctx);
 int selinux_xfrm_policy_delete(struct xfrm_sec_ctx *ctx);
 int selinux_xfrm_state_alloc(struct xfrm_state *x,
-        struct xfrm_user_sec_ctx *sec_ctx, u32 secid);
+                             struct xfrm_user_sec_ctx *uctx);
+int selinux_xfrm_state_alloc_acquire(struct xfrm_state *x,
+                                     struct xfrm_sec_ctx *polsec, u32 secid);
 void selinux_xfrm_state_free(struct xfrm_state *x);
 int selinux_xfrm_state_delete(struct xfrm_state *x);
 int selinux_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
 int selinux_xfrm_state_pol_flow_match(struct xfrm_state *x,
-                        struct xfrm_policy *xp, const struct flowi *fl);
+                                      struct xfrm_policy *xp,
+                                      const struct flowi *fl);
-/*
- * Extract the security blob from the sock (it's actually on the socket)
- */
-static inline struct inode_security_struct *get_sock_isec(struct sock *sk)
-{
-        if (!sk->sk_socket)
-                return NULL;
-        return SOCK_INODE(sk->sk_socket)->i_security;
-}
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
 extern atomic_t selinux_xfrm_refcount;
@@ -42,10 +34,10 @@ static inline int selinux_xfrm_enabled(void)
        return (atomic_read(&selinux_xfrm_refcount) > 0);
 }
-int selinux_xfrm_sock_rcv_skb(u32 sid, struct sk_buff *skb,
+int selinux_xfrm_sock_rcv_skb(u32 sk_sid, struct sk_buff *skb,
-                        struct common_audit_data *ad);
+                              struct common_audit_data *ad);
-int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb,
+int selinux_xfrm_postroute_last(u32 sk_sid, struct sk_buff *skb,
-                        struct common_audit_data *ad, u8 proto);
+                                struct common_audit_data *ad, u8 proto);
 int selinux_xfrm_decode_session(struct sk_buff *skb, u32 *sid, int ckall);
 static inline void selinux_xfrm_notify_policyload(void)
@@ -64,19 +56,21 @@ static inline int selinux_xfrm_enabled(void)
        return 0;
 }
-static inline int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb,
+static inline int selinux_xfrm_sock_rcv_skb(u32 sk_sid, struct sk_buff *skb,
-                        struct common_audit_data *ad)
+                                            struct common_audit_data *ad)
 {
        return 0;
 }
-static inline int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb,
+static inline int selinux_xfrm_postroute_last(u32 sk_sid, struct sk_buff *skb,
-                        struct common_audit_data *ad, u8 proto)
+                                              struct common_audit_data *ad,
+                                              u8 proto)
 {
        return 0;
 }
-static inline int selinux_xfrm_decode_session(struct sk_buff *skb, u32 *sid, int ckall)
+static inline int selinux_xfrm_decode_session(struct sk_buff *skb, u32 *sid,
+                                              int ckall)
 {
        *sid = SECSID_NULL;
        return 0;
@@ -87,10 +81,9 @@ static inline void selinux_xfrm_notify_policyload(void)
 }
 #endif
-static inline void selinux_skb_xfrm_sid(struct sk_buff *skb, u32 *sid)
+static inline int selinux_skb_xfrm_sid(struct sk_buff *skb, u32 *sid)
 {
-        int err = selinux_xfrm_decode_session(skb, sid, 0);
+        return selinux_xfrm_decode_session(skb, sid, 0);
-        BUG_ON(err);
 }
 #endif /* _SELINUX_XFRM_H_ */
diff --git a/security/selinux/netlabel.c b/security/selinux/netlabel.c
index da4b8b233280..6235d052338b 100644
--- a/security/selinux/netlabel.c
+++ b/security/selinux/netlabel.c
@@ -442,8 +442,7 @@ int selinux_netlbl_socket_connect(struct sock *sk, struct sockaddr *addr)
            sksec->nlbl_state != NLBL_CONNLABELED)
                return 0;
-        local_bh_disable();
+        lock_sock(sk);
-        bh_lock_sock_nested(sk);
        /* connected sockets are allowed to disconnect when the address family
         * is set to AF_UNSPEC, if that is what is happening we want to reset
@@ -464,7 +463,6 @@ int selinux_netlbl_socket_connect(struct sock *sk, struct sockaddr *addr)
                sksec->nlbl_state = NLBL_CONNLABELED;
 socket_connect_return:
-        bh_unlock_sock(sk);
+        release_sock(sk);
-        local_bh_enable();
        return rc;
 }
diff --git a/security/selinux/netnode.c b/security/selinux/netnode.c
index c5454c0477c3..03a72c32afd7 100644
--- a/security/selinux/netnode.c
+++ b/security/selinux/netnode.c
@@ -166,6 +166,7 @@ static void sel_netnode_insert(struct sel_netnode *node)
                break;
        default:
                BUG();
+                return;
        }
        /* we need to impose a limit on the growth of the hash table so check
@@ -225,6 +226,7 @@ static int sel_netnode_sid_slow(void *addr, u16 family, u32 *sid)
                break;
        default:
                BUG();
+                ret = -EINVAL;
        }
        if (ret != 0)
                goto out;
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index ff427733c290..5122affe06a8 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -44,7 +44,9 @@
 /* Policy capability filenames */
 static char *policycap_names[] = {
        "network_peer_controls",
-        "open_perms"
+        "open_perms",
+        "redhat1",
+        "always_check_network"
 };
 unsigned int selinux_checkreqprot = CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE;
diff --git a/security/selinux/ss/ebitmap.c b/security/selinux/ss/ebitmap.c
index 30f119b1d1ec..820313a04d49 100644
--- a/security/selinux/ss/ebitmap.c
+++ b/security/selinux/ss/ebitmap.c
@@ -213,7 +213,12 @@ netlbl_import_failure:
 }
 #endif /* CONFIG_NETLABEL */
-int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2)
+/*
+ * Check to see if all the bits set in e2 are also set in e1. Optionally,
+ * if last_e2bit is non-zero, the highest set bit in e2 cannot exceed
+ * last_e2bit.
+ */
+int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2, u32 last_e2bit)
 {
        struct ebitmap_node *n1, *n2;
        int i;
@@ -223,14 +228,25 @@ int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2)
        n1 = e1->node;
        n2 = e2->node;
        while (n1 && n2 && (n1->startbit <= n2->startbit)) {
                if (n1->startbit < n2->startbit) {
                        n1 = n1->next;
                        continue;
                }
-                for (i = 0; i < EBITMAP_UNIT_NUMS; i++) {
+                for (i = EBITMAP_UNIT_NUMS - 1; (i >= 0) && !n2->maps[i]; )
+                        i--;    /* Skip trailing NULL map entries */
+                if (last_e2bit && (i >= 0)) {
+                        u32 lastsetbit = n2->startbit + i * EBITMAP_UNIT_SIZE +
+                                         __fls(n2->maps[i]);
+                        if (lastsetbit > last_e2bit)
+                                return 0;
+                }
+                while (i >= 0) {
                        if ((n1->maps[i] & n2->maps[i]) != n2->maps[i])
                                return 0;
+                        i--;
                }
                n1 = n1->next;
diff --git a/security/selinux/ss/ebitmap.h b/security/selinux/ss/ebitmap.h
index 922f8afa89dd..712c8a7b8e8b 100644
--- a/security/selinux/ss/ebitmap.h
+++ b/security/selinux/ss/ebitmap.h
@@ -16,7 +16,13 @@
 #include <net/netlabel.h>
-#define EBITMAP_UNIT_NUMS       ((32 - sizeof(void *) - sizeof(u32))    \
+#ifdef CONFIG_64BIT
+#define EBITMAP_NODE_SIZE       64
+#else
+#define EBITMAP_NODE_SIZE       32
+#endif
+#define EBITMAP_UNIT_NUMS       ((EBITMAP_NODE_SIZE-sizeof(void *)-sizeof(u32))\
                                        / sizeof(unsigned long))
 #define EBITMAP_UNIT_SIZE       BITS_PER_LONG
 #define EBITMAP_SIZE            (EBITMAP_UNIT_NUMS * EBITMAP_UNIT_SIZE)
@@ -117,7 +123,7 @@ static inline void ebitmap_node_clr_bit(struct ebitmap_node *n,
 int ebitmap_cmp(struct ebitmap *e1, struct ebitmap *e2);
 int ebitmap_cpy(struct ebitmap *dst, struct ebitmap *src);
-int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2);
+int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2, u32 last_e2bit);
 int ebitmap_get_bit(struct ebitmap *e, unsigned long bit);
 int ebitmap_set_bit(struct ebitmap *e, unsigned long bit, int value);
 void ebitmap_destroy(struct ebitmap *e);
diff --git a/security/selinux/ss/mls.c b/security/selinux/ss/mls.c
index 40de8d3f208e..c85bc1ec040c 100644
--- a/security/selinux/ss/mls.c
+++ b/security/selinux/ss/mls.c
@@ -160,8 +160,6 @@ void mls_sid_to_context(struct context *context,
 int mls_level_isvalid(struct policydb *p, struct mls_level *l)
 {
        struct level_datum *levdatum;
-        struct ebitmap_node *node;
-        int i;
        if (!l->sens || l->sens > p->p_levels.nprim)
                return 0;
@@ -170,19 +168,13 @@ int mls_level_isvalid(struct policydb *p, struct mls_level *l)
        if (!levdatum)
                return 0;
-        ebitmap_for_each_positive_bit(&l->cat, node, i) {
+        /*
-                if (i > p->p_cats.nprim)
+         * Return 1 iff all the bits set in l->cat are also be set in
-                        return 0;
+         * levdatum->level->cat and no bit in l->cat is larger than
-                if (!ebitmap_get_bit(&levdatum->level->cat, i)) {
+         * p->p_cats.nprim.
-                        /*
+         */
-                         * Category may not be associated with
+        return ebitmap_contains(&levdatum->level->cat, &l->cat,
-                         * sensitivity.
+                                p->p_cats.nprim);
-                         */
-                        return 0;
-                }
-        }
-        return 1;
 }
 int mls_range_isvalid(struct policydb *p, struct mls_range *r)
diff --git a/security/selinux/ss/mls_types.h b/security/selinux/ss/mls_types.h
index 03bed52a8052..e93648774137 100644
--- a/security/selinux/ss/mls_types.h
+++ b/security/selinux/ss/mls_types.h
@@ -35,7 +35,7 @@ static inline int mls_level_eq(struct mls_level *l1, struct mls_level *l2)
 static inline int mls_level_dom(struct mls_level *l1, struct mls_level *l2)
 {
        return ((l1->sens >= l2->sens) &&
-                ebitmap_contains(&l1->cat, &l2->cat));
+                ebitmap_contains(&l1->cat, &l2->cat, 0));
 }
 #define mls_level_incomp(l1, l2) \
diff --git a/security/selinux/ss/policydb.c b/security/selinux/ss/policydb.c
index c8adde3aff8f..f6195ebde3c9 100644
--- a/security/selinux/ss/policydb.c
+++ b/security/selinux/ss/policydb.c
@@ -3203,9 +3203,8 @@ static int range_write_helper(void *key, void *data, void *ptr)
 static int range_write(struct policydb *p, void *fp)
 {
-        size_t nel;
        __le32 buf[1];
-        int rc;
+        int rc, nel;
        struct policy_data pd;
        pd.p = p;
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index b4feecc3fe01..ee470a0b5c27 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -72,6 +72,7 @@
 int selinux_policycap_netpeer;
 int selinux_policycap_openperm;
+int selinux_policycap_alwaysnetwork;
 static DEFINE_RWLOCK(policy_rwlock);
@@ -1812,6 +1813,8 @@ static void security_load_policycaps(void)
                                                  POLICYDB_CAPABILITY_NETPEER);
        selinux_policycap_openperm = ebitmap_get_bit(&policydb.policycaps,
                                                  POLICYDB_CAPABILITY_OPENPERM);
+        selinux_policycap_alwaysnetwork = ebitmap_get_bit(&policydb.policycaps,
+                                                  POLICYDB_CAPABILITY_ALWAYSNETWORK);
 }
 static int security_preserve_bools(struct policydb *p);
@@ -2323,43 +2326,74 @@ out:
 /**
 * security_fs_use - Determine how to handle labeling for a filesystem.
- * @fstype: filesystem type
+ * @sb: superblock in question
- * @behavior: labeling behavior
- * @sid: SID for filesystem (superblock)
 */
-int security_fs_use(
+int security_fs_use(struct super_block *sb)
-        const char *fstype,
-        unsigned int *behavior,
-        u32 *sid)
 {
        int rc = 0;
        struct ocontext *c;
+        struct superblock_security_struct *sbsec = sb->s_security;
+        const char *fstype = sb->s_type->name;
+        const char *subtype = (sb->s_subtype && sb->s_subtype[0]) ? sb->s_subtype : NULL;
+        struct ocontext *base = NULL;
        read_lock(&policy_rwlock);
-        c = policydb.ocontexts[OCON_FSUSE];
+        for (c = policydb.ocontexts[OCON_FSUSE]; c; c = c->next) {
-        while (c) {
+                char *sub;
-                if (strcmp(fstype, c->u.name) == 0)
+                int baselen;
+                baselen = strlen(fstype);
+                /* if base does not match, this is not the one */
+                if (strncmp(fstype, c->u.name, baselen))
+                        continue;
+                /* if there is no subtype, this is the one! */
+                if (!subtype)
+                        break;
+                /* skip past the base in this entry */
+                sub = c->u.name + baselen;
+                /* entry is only a base. save it. keep looking for subtype */
+                if (sub[0] == '\0') {
+                        base = c;
+                        continue;
+                }
+                /* entry is not followed by a subtype, so it is not a match */
+                if (sub[0] != '.')
+                        continue;
+                /* whew, we found a subtype of this fstype */
+                sub++; /* move past '.' */
+                /* exact match of fstype AND subtype */
+                if (!strcmp(subtype, sub))
                        break;
-                c = c->next;
        }
+        /* in case we had found an fstype match but no subtype match */
+        if (!c)
+                c = base;
        if (c) {
-                *behavior = c->v.behavior;
+                sbsec->behavior = c->v.behavior;
                if (!c->sid[0]) {
                        rc = sidtab_context_to_sid(&sidtab, &c->context[0],
                                                   &c->sid[0]);
                        if (rc)
                                goto out;
                }
-                *sid = c->sid[0];
+                sbsec->sid = c->sid[0];
        } else {
-                rc = security_genfs_sid(fstype, "/", SECCLASS_DIR, sid);
+                rc = security_genfs_sid(fstype, "/", SECCLASS_DIR, &sbsec->sid);
                if (rc) {
-                        *behavior = SECURITY_FS_USE_NONE;
+                        sbsec->behavior = SECURITY_FS_USE_NONE;
                        rc = 0;
                } else {
-                        *behavior = SECURITY_FS_USE_GENFS;
+                        sbsec->behavior = SECURITY_FS_USE_GENFS;
                }
        }
diff --git a/security/selinux/xfrm.c b/security/selinux/xfrm.c
index d03081886214..a91d205ec0c6 100644
--- a/security/selinux/xfrm.c
+++ b/security/selinux/xfrm.c
@@ -56,7 +56,7 @@
 atomic_t selinux_xfrm_refcount = ATOMIC_INIT(0);
 /*
- * Returns true if an LSM/SELinux context
+ * Returns true if the context is an LSM/SELinux context.
 */
 static inline int selinux_authorizable_ctx(struct xfrm_sec_ctx *ctx)
 {
@@ -66,7 +66,7 @@ static inline int selinux_authorizable_ctx(struct xfrm_sec_ctx *ctx)
 }
 /*
- * Returns true if the xfrm contains a security blob for SELinux
+ * Returns true if the xfrm contains a security blob for SELinux.
 */
 static inline int selinux_authorizable_xfrm(struct xfrm_state *x)
 {
@@ -74,48 +74,111 @@ static inline int selinux_authorizable_xfrm(struct xfrm_state *x)
 }
 /*
- * LSM hook implementation that authorizes that a flow can use
+ * Allocates a xfrm_sec_state and populates it using the supplied security
- * a xfrm policy rule.
+ * xfrm_user_sec_ctx context.
 */
-int selinux_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir)
+static int selinux_xfrm_alloc_user(struct xfrm_sec_ctx **ctxp,
+                                   struct xfrm_user_sec_ctx *uctx)
 {
        int rc;
-        u32 sel_sid;
+        const struct task_security_struct *tsec = current_security();
+        struct xfrm_sec_ctx *ctx = NULL;
+        u32 str_len;
-        /* Context sid is either set to label or ANY_ASSOC */
+        if (ctxp == NULL || uctx == NULL ||
-        if (ctx) {
+            uctx->ctx_doi != XFRM_SC_DOI_LSM ||
-                if (!selinux_authorizable_ctx(ctx))
+            uctx->ctx_alg != XFRM_SC_ALG_SELINUX)
-                        return -EINVAL;
+                return -EINVAL;
-                sel_sid = ctx->ctx_sid;
-        } else
-                /*
-                 * All flows should be treated as polmatch'ing an
-                 * otherwise applicable "non-labeled" policy. This
-                 * would prevent inadvertent "leaks".
-                 */
-                return 0;
-        rc = avc_has_perm(fl_secid, sel_sid, SECCLASS_ASSOCIATION,
+        str_len = uctx->ctx_len;
-                          ASSOCIATION__POLMATCH,
+        if (str_len >= PAGE_SIZE)
-                          NULL);
+                return -ENOMEM;
-        if (rc == -EACCES)
+        ctx = kmalloc(sizeof(*ctx) + str_len + 1, GFP_KERNEL);
-                return -ESRCH;
+        if (!ctx)
+                return -ENOMEM;
+        ctx->ctx_doi = XFRM_SC_DOI_LSM;
+        ctx->ctx_alg = XFRM_SC_ALG_SELINUX;
+        ctx->ctx_len = str_len;
+        memcpy(ctx->ctx_str, &uctx[1], str_len);
+        ctx->ctx_str[str_len] = '\0';
+        rc = security_context_to_sid(ctx->ctx_str, str_len, &ctx->ctx_sid);
+        if (rc)
+                goto err;
+        rc = avc_has_perm(tsec->sid, ctx->ctx_sid,
+                          SECCLASS_ASSOCIATION, ASSOCIATION__SETCONTEXT, NULL);
+        if (rc)
+                goto err;
+        *ctxp = ctx;
+        atomic_inc(&selinux_xfrm_refcount);
+        return 0;
+err:
+        kfree(ctx);
        return rc;
 }
 /*
+ * Free the xfrm_sec_ctx structure.
+ */
+static void selinux_xfrm_free(struct xfrm_sec_ctx *ctx)
+{
+        if (!ctx)
+                return;
+        atomic_dec(&selinux_xfrm_refcount);
+        kfree(ctx);
+}
+/*
+ * Authorize the deletion of a labeled SA or policy rule.
+ */
+static int selinux_xfrm_delete(struct xfrm_sec_ctx *ctx)
+{
+        const struct task_security_struct *tsec = current_security();
+        if (!ctx)
+                return 0;
+        return avc_has_perm(tsec->sid, ctx->ctx_sid,
+                            SECCLASS_ASSOCIATION, ASSOCIATION__SETCONTEXT,
+                            NULL);
+}
+/*
+ * LSM hook implementation that authorizes that a flow can use a xfrm policy
+ * rule.
+ */
+int selinux_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir)
+{
+        int rc;
+        /* All flows should be treated as polmatch'ing an otherwise applicable
+         * "non-labeled" policy. This would prevent inadvertent "leaks". */
+        if (!ctx)
+                return 0;
+        /* Context sid is either set to label or ANY_ASSOC */
+        if (!selinux_authorizable_ctx(ctx))
+                return -EINVAL;
+        rc = avc_has_perm(fl_secid, ctx->ctx_sid,
+                          SECCLASS_ASSOCIATION, ASSOCIATION__POLMATCH, NULL);
+        return (rc == -EACCES ? -ESRCH : rc);
+}
+/*
 * LSM hook implementation that authorizes that a state matches
 * the given policy, flow combo.
 */
+int selinux_xfrm_state_pol_flow_match(struct xfrm_state *x,
-int selinux_xfrm_state_pol_flow_match(struct xfrm_state *x, struct xfrm_policy *xp,
+                                      struct xfrm_policy *xp,
-                        const struct flowi *fl)
+                                      const struct flowi *fl)
 {
        u32 state_sid;
-        int rc;
        if (!xp->security)
                if (x->security)
@@ -138,187 +201,80 @@ int selinux_xfrm_state_pol_flow_match(struct xfrm_state *x, struct xfrm_policy *
        if (fl->flowi_secid != state_sid)
                return 0;
-        rc = avc_has_perm(fl->flowi_secid, state_sid, SECCLASS_ASSOCIATION,
+        /* We don't need a separate SA Vs. policy polmatch check since the SA
-                          ASSOCIATION__SENDTO,
+         * is now of the same label as the flow and a flow Vs. policy polmatch
-                          NULL)? 0:1;
+         * check had already happened in selinux_xfrm_policy_lookup() above. */
+        return (avc_has_perm(fl->flowi_secid, state_sid,
-        /*
+                            SECCLASS_ASSOCIATION, ASSOCIATION__SENDTO,
-         * We don't need a separate SA Vs. policy polmatch check
+                            NULL) ? 0 : 1);
-         * since the SA is now of the same label as the flow and
-         * a flow Vs. policy polmatch check had already happened
-         * in selinux_xfrm_policy_lookup() above.
-         */
-        return rc;
 }
 /*
 * LSM hook implementation that checks and/or returns the xfrm sid for the
 * incoming packet.
 */
 int selinux_xfrm_decode_session(struct sk_buff *skb, u32 *sid, int ckall)
 {
+        u32 sid_session = SECSID_NULL;
        struct sec_path *sp;
-        *sid = SECSID_NULL;
        if (skb == NULL)
-                return 0;
+                goto out;
        sp = skb->sp;
        if (sp) {
-                int i, sid_set = 0;
+                int i;
-                for (i = sp->len-1; i >= 0; i--) {
+                for (i = sp->len - 1; i >= 0; i--) {
                        struct xfrm_state *x = sp->xvec[i];
                        if (selinux_authorizable_xfrm(x)) {
                                struct xfrm_sec_ctx *ctx = x->security;
-                                if (!sid_set) {
+                                if (sid_session == SECSID_NULL) {
-                                        *sid = ctx->ctx_sid;
+                                        sid_session = ctx->ctx_sid;
-                                        sid_set = 1;
                                        if (!ckall)
-                                                break;
+                                                goto out;
-                                } else if (*sid != ctx->ctx_sid)
+                                } else if (sid_session != ctx->ctx_sid) {
+                                        *sid = SECSID_NULL;
                                        return -EINVAL;
+                                }
                        }
                }
        }
-        return 0;
-}
-/*
- * Security blob allocation for xfrm_policy and xfrm_state
- * CTX does not have a meaningful value on input
- */
-static int selinux_xfrm_sec_ctx_alloc(struct xfrm_sec_ctx **ctxp,
-        struct xfrm_user_sec_ctx *uctx, u32 sid)
-{
-        int rc = 0;
-        const struct task_security_struct *tsec = current_security();
-        struct xfrm_sec_ctx *ctx = NULL;
-        char *ctx_str = NULL;
-        u32 str_len;
-        BUG_ON(uctx && sid);
-        if (!uctx)
-                goto not_from_user;
-        if (uctx->ctx_alg != XFRM_SC_ALG_SELINUX)
-                return -EINVAL;
-        str_len = uctx->ctx_len;
-        if (str_len >= PAGE_SIZE)
-                return -ENOMEM;
-        *ctxp = ctx = kmalloc(sizeof(*ctx) +
-                              str_len + 1,
-                              GFP_KERNEL);
-        if (!ctx)
-                return -ENOMEM;
-        ctx->ctx_doi = uctx->ctx_doi;
-        ctx->ctx_len = str_len;
-        ctx->ctx_alg = uctx->ctx_alg;
-        memcpy(ctx->ctx_str,
-               uctx+1,
-               str_len);
-        ctx->ctx_str[str_len] = 0;
-        rc = security_context_to_sid(ctx->ctx_str,
-                                     str_len,
-                                     &ctx->ctx_sid);
-        if (rc)
-                goto out;
-        /*
-         * Does the subject have permission to set security context?
-         */
-        rc = avc_has_perm(tsec->sid, ctx->ctx_sid,
-                          SECCLASS_ASSOCIATION,
-                          ASSOCIATION__SETCONTEXT, NULL);
-        if (rc)
-                goto out;
-        return rc;
-not_from_user:
-        rc = security_sid_to_context(sid, &ctx_str, &str_len);
-        if (rc)
-                goto out;
-        *ctxp = ctx = kmalloc(sizeof(*ctx) +
-                              str_len,
-                              GFP_ATOMIC);
-        if (!ctx) {
-                rc = -ENOMEM;
-                goto out;
-        }
-        ctx->ctx_doi = XFRM_SC_DOI_LSM;
-        ctx->ctx_alg = XFRM_SC_ALG_SELINUX;
-        ctx->ctx_sid = sid;
-        ctx->ctx_len = str_len;
-        memcpy(ctx->ctx_str,
-               ctx_str,
-               str_len);
-        goto out2;
 out:
-        *ctxp = NULL;
+        *sid = sid_session;
-        kfree(ctx);
+        return 0;
-out2:
-        kfree(ctx_str);
-        return rc;
 }
 /*
- * LSM hook implementation that allocs and transfers uctx spec to
+ * LSM hook implementation that allocs and transfers uctx spec to xfrm_policy.
- * xfrm_policy.
 */
 int selinux_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
                              struct xfrm_user_sec_ctx *uctx)
 {
-        int err;
+        return selinux_xfrm_alloc_user(ctxp, uctx);
-        BUG_ON(!uctx);
-        err = selinux_xfrm_sec_ctx_alloc(ctxp, uctx, 0);
-        if (err == 0)
-                atomic_inc(&selinux_xfrm_refcount);
-        return err;
 }
 /*
- * LSM hook implementation that copies security data structure from old to
+ * LSM hook implementation that copies security data structure from old to new
- * new for policy cloning.
+ * for policy cloning.
 */
 int selinux_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx,
                              struct xfrm_sec_ctx **new_ctxp)
 {
        struct xfrm_sec_ctx *new_ctx;
-        if (old_ctx) {
+        if (!old_ctx)
-                new_ctx = kmalloc(sizeof(*old_ctx) + old_ctx->ctx_len,
+                return 0;
-                                  GFP_ATOMIC);
-                if (!new_ctx)
+        new_ctx = kmemdup(old_ctx, sizeof(*old_ctx) + old_ctx->ctx_len,
-                        return -ENOMEM;
+                          GFP_ATOMIC);
+        if (!new_ctx)
+                return -ENOMEM;
+        atomic_inc(&selinux_xfrm_refcount);
+        *new_ctxp = new_ctx;
-                memcpy(new_ctx, old_ctx, sizeof(*new_ctx));
-                memcpy(new_ctx->ctx_str, old_ctx->ctx_str, new_ctx->ctx_len);
-                atomic_inc(&selinux_xfrm_refcount);
-                *new_ctxp = new_ctx;
-        }
        return 0;
 }
@@ -327,8 +283,7 @@ int selinux_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx,
 */
 void selinux_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
 {
-        atomic_dec(&selinux_xfrm_refcount);
+        selinux_xfrm_free(ctx);
-        kfree(ctx);
 }
 /*
@@ -336,31 +291,55 @@ void selinux_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
 */
 int selinux_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
 {
-        const struct task_security_struct *tsec = current_security();
+        return selinux_xfrm_delete(ctx);
+}
-        if (!ctx)
-                return 0;
-        return avc_has_perm(tsec->sid, ctx->ctx_sid,
+/*
-                            SECCLASS_ASSOCIATION, ASSOCIATION__SETCONTEXT,
+ * LSM hook implementation that allocates a xfrm_sec_state, populates it using
-                            NULL);
+ * the supplied security context, and assigns it to the xfrm_state.
+ */
+int selinux_xfrm_state_alloc(struct xfrm_state *x,
+                             struct xfrm_user_sec_ctx *uctx)
+{
+        return selinux_xfrm_alloc_user(&x->security, uctx);
 }
 /*
- * LSM hook implementation that allocs and transfers sec_ctx spec to
+ * LSM hook implementation that allocates a xfrm_sec_state and populates based
- * xfrm_state.
+ * on a secid.
 */
-int selinux_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *uctx,
+int selinux_xfrm_state_alloc_acquire(struct xfrm_state *x,
-                u32 secid)
+                                     struct xfrm_sec_ctx *polsec, u32 secid)
 {
-        int err;
+        int rc;
+        struct xfrm_sec_ctx *ctx;
+        char *ctx_str = NULL;
+        int str_len;
+        if (!polsec)
+                return 0;
-        BUG_ON(!x);
+        if (secid == 0)
+                return -EINVAL;
-        err = selinux_xfrm_sec_ctx_alloc(&x->security, uctx, secid);
+        rc = security_sid_to_context(secid, &ctx_str, &str_len);
-        if (err == 0)
+        if (rc)
-                atomic_inc(&selinux_xfrm_refcount);
+                return rc;
-        return err;
+        ctx = kmalloc(sizeof(*ctx) + str_len, GFP_ATOMIC);
+        if (!ctx)
+                return -ENOMEM;
+        ctx->ctx_doi = XFRM_SC_DOI_LSM;
+        ctx->ctx_alg = XFRM_SC_ALG_SELINUX;
+        ctx->ctx_sid = secid;
+        ctx->ctx_len = str_len;
+        memcpy(ctx->ctx_str, ctx_str, str_len);
+        kfree(ctx_str);
+        x->security = ctx;
+        atomic_inc(&selinux_xfrm_refcount);
+        return 0;
 }
 /*
@@ -368,24 +347,15 @@ int selinux_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *uct
 */
 void selinux_xfrm_state_free(struct xfrm_state *x)
 {
-        atomic_dec(&selinux_xfrm_refcount);
+        selinux_xfrm_free(x->security);
-        kfree(x->security);
 }
- /*
+/*
-  * LSM hook implementation that authorizes deletion of labeled SAs.
+ * LSM hook implementation that authorizes deletion of labeled SAs.
-  */
+ */
 int selinux_xfrm_state_delete(struct xfrm_state *x)
 {
-        const struct task_security_struct *tsec = current_security();
+        return selinux_xfrm_delete(x->security);
-        struct xfrm_sec_ctx *ctx = x->security;
-        if (!ctx)
-                return 0;
-        return avc_has_perm(tsec->sid, ctx->ctx_sid,
-                            SECCLASS_ASSOCIATION, ASSOCIATION__SETCONTEXT,
-                            NULL);
 }
 /*
@@ -395,14 +365,12 @@ int selinux_xfrm_state_delete(struct xfrm_state *x)
 * we need to check for unlabelled access since this may not have
 * gone thru the IPSec process.
 */
-int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb,
+int selinux_xfrm_sock_rcv_skb(u32 sk_sid, struct sk_buff *skb,
-                                struct common_audit_data *ad)
+                              struct common_audit_data *ad)
 {
-        int i, rc = 0;
+        int i;
-        struct sec_path *sp;
+        struct sec_path *sp = skb->sp;
-        u32 sel_sid = SECINITSID_UNLABELED;
+        u32 peer_sid = SECINITSID_UNLABELED;
-        sp = skb->sp;
        if (sp) {
                for (i = 0; i < sp->len; i++) {
@@ -410,23 +378,17 @@ int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb,
                        if (x && selinux_authorizable_xfrm(x)) {
                                struct xfrm_sec_ctx *ctx = x->security;
-                                sel_sid = ctx->ctx_sid;
+                                peer_sid = ctx->ctx_sid;
                                break;
                        }
                }
        }
-        /*
+        /* This check even when there's no association involved is intended,
-         * This check even when there's no association involved is
+         * according to Trent Jaeger, to make sure a process can't engage in
-         * intended, according to Trent Jaeger, to make sure a
+         * non-IPsec communication unless explicitly allowed by policy. */
-         * process can't engage in non-ipsec communication unless
+        return avc_has_perm(sk_sid, peer_sid,
-         * explicitly allowed by policy.
+                            SECCLASS_ASSOCIATION, ASSOCIATION__RECVFROM, ad);
-         */
-        rc = avc_has_perm(isec_sid, sel_sid, SECCLASS_ASSOCIATION,
-                          ASSOCIATION__RECVFROM, ad);
-        return rc;
 }
 /*
@@ -436,49 +398,38 @@ int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb,
 * If we do have a authorizable security association, then it has already been
 * checked in the selinux_xfrm_state_pol_flow_match hook above.
 */
-int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb,
+int selinux_xfrm_postroute_last(u32 sk_sid, struct sk_buff *skb,
-                                        struct common_audit_data *ad, u8 proto)
+                                struct common_audit_data *ad, u8 proto)
 {
        struct dst_entry *dst;
-        int rc = 0;
-        dst = skb_dst(skb);
-        if (dst) {
-                struct dst_entry *dst_test;
-                for (dst_test = dst; dst_test != NULL;
-                     dst_test = dst_test->child) {
-                        struct xfrm_state *x = dst_test->xfrm;
-                        if (x && selinux_authorizable_xfrm(x))
-                                goto out;
-                }
-        }
        switch (proto) {
        case IPPROTO_AH:
        case IPPROTO_ESP:
        case IPPROTO_COMP:
-                /*
+                /* We should have already seen this packet once before it
-                 * We should have already seen this packet once before
+                 * underwent xfrm(s). No need to subject it to the unlabeled
-                 * it underwent xfrm(s). No need to subject it to the
+                 * check. */
-                 * unlabeled check.
+                return 0;
-                 */
-                goto out;
        default:
                break;
        }
-        /*
+        dst = skb_dst(skb);
-         * This check even when there's no association involved is
+        if (dst) {
-         * intended, according to Trent Jaeger, to make sure a
+                struct dst_entry *iter;
-         * process can't engage in non-ipsec communication unless
-         * explicitly allowed by policy.
-         */
-        rc = avc_has_perm(isec_sid, SECINITSID_UNLABELED, SECCLASS_ASSOCIATION,
+                for (iter = dst; iter != NULL; iter = iter->child) {
-                          ASSOCIATION__SENDTO, ad);
+                        struct xfrm_state *x = iter->xfrm;
-out:
-        return rc;
+                        if (x && selinux_authorizable_xfrm(x))
+                                return 0;
+                }
+        }
+        /* This check even when there's no association involved is intended,
+         * according to Trent Jaeger, to make sure a process can't engage in
+         * non-IPsec communication unless explicitly allowed by policy. */
+        return avc_has_perm(sk_sid, SECINITSID_UNLABELED,
+                            SECCLASS_ASSOCIATION, ASSOCIATION__SENDTO, ad);
 }
diff --git a/security/smack/smack.h b/security/smack/smack.h
index 076b8e8a51ab..364cc64fce71 100644
--- a/security/smack/smack.h
+++ b/security/smack/smack.h
@@ -177,9 +177,13 @@ struct smk_port_label {
 #define SMACK_CIPSO_MAXCATNUM           184     /* 23 * 8 */
 /*
- * Flag for transmute access
+ * Flags for untraditional access modes.
+ * It shouldn't be necessary to avoid conflicts with definitions
+ * in fs.h, but do so anyway.
 */
-#define MAY_TRANSMUTE   64
+#define MAY_TRANSMUTE   0x00001000      /* Controls directory labeling */
+#define MAY_LOCK        0x00002000      /* Locks should be writes, but ... */
 /*
 * Just to make the common cases easier to deal with
 */
@@ -188,9 +192,9 @@ struct smk_port_label {
 #define MAY_NOT         0
 /*
- * Number of access types used by Smack (rwxat)
+ * Number of access types used by Smack (rwxatl)
 */
-#define SMK_NUM_ACCESS_TYPE 5
+#define SMK_NUM_ACCESS_TYPE 6
 /* SMACK data */
 struct smack_audit_data {
diff --git a/security/smack/smack_access.c b/security/smack/smack_access.c
index b3b59b1e93d6..14293cd9b1e5 100644
--- a/security/smack/smack_access.c
+++ b/security/smack/smack_access.c
@@ -84,6 +84,8 @@ int log_policy = SMACK_AUDIT_DENIED;
 *
 * Do the object check first because that is more
 * likely to differ.
+ *
+ * Allowing write access implies allowing locking.
 */
 int smk_access_entry(char *subject_label, char *object_label,
                        struct list_head *rule_list)
@@ -99,6 +101,11 @@ int smk_access_entry(char *subject_label, char *object_label,
                }
        }
+        /*
+         * MAY_WRITE implies MAY_LOCK.
+         */
+        if ((may & MAY_WRITE) == MAY_WRITE)
+                may |= MAY_LOCK;
        return may;
 }
@@ -245,6 +252,7 @@ out_audit:
 static inline void smack_str_from_perm(char *string, int access)
 {
        int i = 0;
        if (access & MAY_READ)
                string[i++] = 'r';
        if (access & MAY_WRITE)
@@ -255,6 +263,8 @@ static inline void smack_str_from_perm(char *string, int access)
                string[i++] = 'a';
        if (access & MAY_TRANSMUTE)
                string[i++] = 't';
+        if (access & MAY_LOCK)
+                string[i++] = 'l';
        string[i] = '\0';
 }
 /**
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 8825375cc031..b0be893ad44d 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -185,7 +185,7 @@ static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode)
        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
        smk_ad_setfield_u_tsk(&ad, ctp);
-        rc = smk_curacc(skp->smk_known, MAY_READWRITE, &ad);
+        rc = smk_curacc(skp->smk_known, mode, &ad);
        return rc;
 }
@@ -1146,7 +1146,7 @@ static int smack_file_ioctl(struct file *file, unsigned int cmd,
 * @file: the object
 * @cmd: unused
 *
- * Returns 0 if current has write access, error code otherwise
+ * Returns 0 if current has lock access, error code otherwise
 */
 static int smack_file_lock(struct file *file, unsigned int cmd)
 {
@@ -1154,7 +1154,7 @@ static int smack_file_lock(struct file *file, unsigned int cmd)
        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
        smk_ad_setfield_u_fs_path(&ad, file->f_path);
-        return smk_curacc(file->f_security, MAY_WRITE, &ad);
+        return smk_curacc(file->f_security, MAY_LOCK, &ad);
 }
 /**
@@ -1178,8 +1178,13 @@ static int smack_file_fcntl(struct file *file, unsigned int cmd,
        switch (cmd) {
        case F_GETLK:
+                break;
        case F_SETLK:
        case F_SETLKW:
+                smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
+                smk_ad_setfield_u_fs_path(&ad, file->f_path);
+                rc = smk_curacc(file->f_security, MAY_LOCK, &ad);
+                break;
        case F_SETOWN:
        case F_SETSIG:
                smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c
index 80f4b4a45725..160aa08e3cd5 100644
--- a/security/smack/smackfs.c
+++ b/security/smack/smackfs.c
@@ -139,7 +139,7 @@ const char *smack_cipso_option = SMACK_CIPSO_OPTION;
 * SMK_LOADLEN: Smack rule length
 */
 #define SMK_OACCESS     "rwxa"
-#define SMK_ACCESS      "rwxat"
+#define SMK_ACCESS      "rwxatl"
 #define SMK_OACCESSLEN  (sizeof(SMK_OACCESS) - 1)
 #define SMK_ACCESSLEN   (sizeof(SMK_ACCESS) - 1)
 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
@@ -282,6 +282,10 @@ static int smk_perm_from_str(const char *string)
                case 'T':
                        perm |= MAY_TRANSMUTE;
                        break;
+                case 'l':
+                case 'L':
+                        perm |= MAY_LOCK;
+                        break;
                default:
                        return perm;
                }
@@ -452,7 +456,7 @@ static ssize_t smk_write_rules_list(struct file *file, const char __user *buf,
                /*
                 * Minor hack for backward compatibility
                 */
-                if (count != SMK_OLOADLEN && count != SMK_LOADLEN)
+                if (count < SMK_OLOADLEN || count > SMK_LOADLEN)
                        return -EINVAL;
        } else {
                if (count >= PAGE_SIZE) {
@@ -592,6 +596,8 @@ static void smk_rule_show(struct seq_file *s, struct smack_rule *srp, int max)
                seq_putc(s, 'a');
        if (srp->smk_access & MAY_TRANSMUTE)
                seq_putc(s, 't');
+        if (srp->smk_access & MAY_LOCK)
+                seq_putc(s, 'l');
        seq_putc(s, '\n');
 }
author	Linus Torvalds <torvalds@linux-foundation.org>	2013-11-21 22:46:00 -0500
committer	Linus Torvalds <torvalds@linux-foundation.org>	2013-11-21 22:46:00 -0500
commit	78dc53c422172a317adb0776dfb687057ffa28b7 (patch)
tree	7c5d15da75d769d01f6a992c24c3490b3867d5b2 /security
parent	3eaded86ac3e7f00fb3eeb8162d89e9a34e42fb0 (diff)
parent	62fe318256befbd1b4a6765e71d9c997f768fe79 (diff)