KEYS: Sanitize the garbage collector
Subsystems (14)
Jarkko Sakkinen
maintainerv6 cover KEYS: Sanitize the garbage collector
1. Replace key_type_dead retyping with module reference pinning so live keys and restrictions keep their backing key_type module loaded until key_gc_unused_keys() or keyring_destroy() completes.
2. Process serial-tree scans and graveyard destruction in fixed 64-key chunks to a bound workqueue execution latency without hurting overall throughput for a significant amount.
The first part has a user-space visible effect: rmmod returns -EBUSY while keys or keyring restrictions still pin the backing module.
Internal key caches or transport state bottlenecks are addressed by either clearing their private caches on last-client teardown or splitting key types into dedicated provider modules.
CHANGES
=======
v6:
- Split "KEYS: trusted: TEE: Synchronize session lifetime" into two patches:
1. "KEYS: trusted: Update static calls before init"
2. "KEYS: trusted: TEE: Synchronize session lifetime" No actual code changes.
v5:
- Another round of fixes resolving Sashiko remarks.
- Reordered TEE session lifetime synchronization patch before suppressing sysfs bind attributes.
- Release conn->key in rxrpc_process_event() on init_connection_security() failure
- Update Documentation/networking/rxrpc.rst to reference net/rxrpc/security.c instead of net/rxrpc/server_key.c.
- Store the delay-adjusted reap timestamp in gc->end in key_garbage_collector() instead of recording unadjusted key->expiry and adding key_gc_delay a second time.
v4:
- Replaced WARN_ON() around fallible keyring_clear() in CIFS idmap and SPNEGO cache-clearing helpers with pr_warn_ratelimited().
- Moved key garbage collection from the shared events workqueue onto a dedicated WQ_MEM_RECLAIM | WQ_PERCPU workqueue (key_gc), allocated in key_init(), so WQ_MEM_RECLAIM workers (nfsiod/cifsiod) and reclaim paths can flush key GC safely.
v3:
- Split dns_resolver and rxrpc key types into dedicated provider modules (dns_resolver_key.ko and rxrpc_keys.ko) instead of client refcounting, so cached or retained keys do not pin dns_resolver.ko or rxrpc.ko.
- Dropped the standalone nvme-keyring fix as it was picked up by the subsystem maintainers.
- Hardened key_gc_flush() to serialize against chunked key_gc_work continuations, and fixed a restriction module reference leak on failed keyring instantiation.
v2:
- Used v1 as a test probe for Sashiko to detect the corner cases instead of trying to resolve even the known ones beforehand.
- Converted the client subsystems to be compatible with the module pinning semantics.
VERSIONS
========
- v5:
https://lore.kernel.org/keyrings/[email protected]/#t
- v4:
https://lore.kernel.org/keyrings/[email protected]/
- v3:
https://lore.kernel.org/keyrings/[email protected]/
- v2:
https://lore.kernel.org/linux-integrity/[email protected]/
Jarkko Sakkinen (13):
KEYS: Add key_gc_flush() for draining RCU callbacks
dns_resolver: Move the key type into a separate module
NFSv4: Clear idmap keyring cache when the last client unloads
smb: client: Clear idmap/SPNEGO caches when the last session is
unloaded
s390/cert_store: Start tracking subsystem keys
KEYS: trusted: Update static calls before init
KEYS: trusted: TEE: Synchronize session lifetime
KEYS: trusted: TEE: Disable sysfs bind attributes
rxrpc: Release conn->key when init_connection_security() fails
rxrpc: Move key types to their own module
KEYS: Pin the backing kernel module for a key type
KEYS: Remove key_type_dead
KEYS: key_garbage_collector(): process in chunks
Documentation/networking/rxrpc.rst | 2 +- arch/s390/kernel/cert_store.c | 161 +++++------- fs/nfs/nfs4idmap.c | 21 ++ fs/smb/client/cifs_spnego.c | 12 + fs/smb/client/cifsacl.c | 12 + fs/smb/client/cifsproto.h | 8 + fs/smb/client/misc.c | 19 +- include/linux/key-type.h | 6 +- include/linux/key.h | 2 + net/Makefile | 4 +- net/dns_resolver/Kconfig | 15 ++ net/dns_resolver/Makefile | 4 +- net/dns_resolver/dns_key.c | 65 +---- net/dns_resolver/dns_query.c | 64 +++++ net/dns_resolver/internal.h | 5 - net/rxrpc/Kconfig | 20 ++ net/rxrpc/Makefile | 7 +- net/rxrpc/af_rxrpc.c | 19 +- net/rxrpc/ar-internal.h | 25 +- net/rxrpc/conn_event.c | 7 +- net/rxrpc/key.c | 122 +++------ net/rxrpc/proc.c | 2 +- net/rxrpc/rxgk.c | 66 ----- net/rxrpc/rxkad.c | 47 ---- net/rxrpc/security.c | 184 ++++++++++++++ net/rxrpc/server_key.c | 260 +++++++++++-------- security/keys/gc.c | 289 ++++++++++------------ security/keys/internal.h | 8 +- security/keys/key.c | 65 +++-- security/keys/keyring.c | 88 +++---- security/keys/trusted-keys/trusted_core.c | 15 +- security/keys/trusted-keys/trusted_tee.c | 89 +++++-- 32 files changed, 932 insertions(+), 781 deletions(-)
--
2.47.3
Jarkko Sakkinen
maintainerPATCH v6 1/13 KEYS: Add key_gc_flush() for draining RCU callbacks
keyring_clear() and key_invalidate() release keyring links via call_rcu(), and key_put() defers final key destruction to key_gc_work.
Once keys pin their type, callers that clear an internal cache before module unload need a synchronous barrier so module references can be dropped before delete_module() checks the refcount.
Add key_gc_flush() for flushing the remaining key_gc_work passes.
--- include/linux/key.h | 2 ++ security/keys/gc.c | 21 +++++++++++++++++---- security/keys/internal.h | 1 + security/keys/key.c | 6 +++++- 4 files changed, 25 insertions(+), 5 deletions(-)
include/linux/key.h +2 -0
@@ -439,6 +439,7 @@ extern int restrict_link_reject(struct key *keyring, struct key *restriction_key);extern int keyring_clear (struct key *keyring); +void key_gc_flush (void ); extern key_ref_t keyring_search(key_ref_t keyring, struct key_type *type,
@@ -526,6 +527,7 @@ extern void key_init(void);#define key_free_user_ns (ns) do { } while(0)#define key_remove_domain (d) do { } while(0)#define key_lookup (k) NULL +#define key_gc_flush () do { } while (0)#endif /* CONFIG_KEYS */ #endif /* __KERNEL__ */
security/keys/gc.c +17 -4
@@ -19,8 +19,21 @@ unsigned key_gc_delay = 5 * 60;* Reaper for unused keys. */ static void key_garbage_collector (struct work_struct *work); + +struct workqueue_struct *key_gc_wq__ro_after_init ;DECLARE_WORK (key_gc_work, key_garbage_collector); +/** +* key_gc_flush - Drain the garbage collector RCU callbacks +*/ +void key_gc_flush (void ) +{ +do { +rcu_barrier (); + }while (flush_work (&key_gc_work)); +} +EXPORT_SYMBOL_GPL (key_gc_flush); +/* * Reaper for links from keyrings to dead keys. */
@@ -57,7 +70,7 @@ void key_schedule_gc(time64_t gc_at)if (gc_at <= now ||test_bit (KEY_GC_REAP_KEYTYPE , &key_gc_flags)) {kdebug ("IMMEDIATE" ); -schedule_work (&key_gc_work); +queue_work (key_gc_wq, &key_gc_work); }else if (gc_at < key_gc_next_run) {kdebug ("DEFERRED" ); key_gc_next_run = gc_at;
@@ -85,7 +98,7 @@ void key_set_expiry(struct key *key, time64_t expiry)void key_schedule_gc_links (void ) {set_bit (KEY_GC_KEY_EXPIRED , &key_gc_flags); -schedule_work (&key_gc_work); +queue_work (key_gc_wq, &key_gc_work); }/*
@@ -119,7 +132,7 @@ void key_gc_keytype(struct key_type *ktype)set_bit (KEY_GC_REAP_KEYTYPE , &key_gc_flags);kdebug ("schedule" ); -schedule_work (&key_gc_work); +queue_work (key_gc_wq, &key_gc_work);kdebug ("sleep" ); wait_on_bit(&key_gc_flags, KEY_GC_REAPING_KEYTYPE,
@@ -322,7 +335,7 @@ static void key_garbage_collector(struct work_struct *work) }if (gc_state &KEY_GC_REAP_AGAIN ) -schedule_work (&key_gc_work); +queue_work (key_gc_wq, &key_gc_work);kleave (" [end %x]" , gc_state);return ;
security/keys/internal.h +1 -0
@@ -164,6 +164,7 @@ extern void key_change_session_keyring(struct callback_head *twork);extern struct work_struct key_gc_work;extern unsigned key_gc_delay; +extern struct workqueue_struct *key_gc_wq;extern void keyring_gc (struct key *keyring,time64_t limit);extern void keyring_restriction_gc (struct key *keyring,struct key_type *dead_type);
security/keys/key.c +5 -1
@@ -670,7 +670,7 @@ void key_put(struct key *key) }/* Mark key as safe for GC after key->user done. */ clear_bit_unlock (KEY_FLAG_USER_ALIVE , &key->flags); -schedule_work (&key_gc_work); +queue_work (key_gc_wq, &key_gc_work); } } }
@@ -1294,6 +1294,10 @@ void __init key_init(void) key_jar =kmem_cache_create ("key_jar" ,sizeof (struct key ),0 ,SLAB_HWCACHE_ALIGN |SLAB_PANIC |SLAB_NO_MERGE ,NULL ); + key_gc_wq =alloc_workqueue ("key_gc" ,WQ_MEM_RECLAIM |WQ_PERCPU ,0 ); +if (!key_gc_wq) +panic ("Cannot create key_gc workqueue\n" ); +/* add the special key types */ list_add_tail (&key_type_keyring.link, &key_types_list);list_add_tail (&key_type_dead.link, &key_types_list);
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 01/13] KEYS: Add key_gc_flush() for draining RCU callbacks
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
keyring_clear()andkey_invalidate()release keyring links viacall_rcu(), andkey_put()defers final key destruction tokey_gc_work.Once keys pin their type, callers that clear an internal cache before module unload need a synchronous barrier so module references can be dropped before
delete_module()checks the refcount.Add
key_gc_flush()for flushing the remainingkey_gc_workpasses.Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Jarkko Sakkinen
maintainerPATCH v6 2/13 dns_resolver: Move the key type into a separate module
In reply to Jarkko SakkinenOnce keys pin to the kernel module of their key type, having the DNS key type in the same modules as the resolver will introduce a circular dependency preventing module_exit() from ever running.
Introduce dns_resolver_key.ko containing key_type_dns_resolver. On a module exit, drop the credentials and call key_gc_flush() in order the drain the remaining RCU callbacks.
--- net/Makefile | 2 +- net/dns_resolver/Kconfig | 15 +++++++++ net/dns_resolver/Makefile | 4 ++- net/dns_resolver/dns_key.c | 65 +++++------------------------------- net/dns_resolver/dns_query.c | 64 +++++++++++++++++++++++++++++++++++ net/dns_resolver/internal.h | 5 --- 6 files changed, 92 insertions(+), 63 deletions(-)
net/Makefile +1 -1
@@ -55,7 +55,7 @@ obj-$(CONFIG_IEEE802154) += ieee802154/ obj-$(CONFIG_MAC802154) += mac802154/ obj-$(CONFIG_SYSCTL) += sysctl_net.o -obj-$(CONFIG_DNS_RESOLVER) += dns_resolver/ +obj-$(CONFIG_DNS_KEY) += dns_resolver/ obj-$(CONFIG_CEPH_LIB) += ceph/ obj-$(CONFIG_BATMAN_ADV) += batman-adv/ obj-$(CONFIG_NFC) += nfc/
net/dns_resolver/Kconfig +15 -0
@@ -1,10 +1,25 @@ # SPDX-License-Identifier: GPL-2.0-only + +# +# Configuration for DNS Resolver key type +# +config DNS_KEY + tristate "DNS Resolver key type" + depends on KEYS + help + Support the key type used to cache DNS lookups independently of + the in-kernel DNS query service. + + To compile this as a module, choose M here: the module is called + dns_resolver_key. + # # Configuration for DNS Resolver # config DNS_RESOLVER tristate "DNS Resolver support" depends on KEYS + select DNS_KEY help Saying Y here will include support for the DNS Resolver key type which can be used to make upcalls to perform DNS lookups in
net/dns_resolver/Makefile +3 -1
@@ -3,6 +3,8 @@ # Makefile for the Linux DNS Resolver. # +obj-$(CONFIG_DNS_KEY) += dns_resolver_key.o obj-$(CONFIG_DNS_RESOLVER) += dns_resolver.o -dns_resolver-y := dns_key.o dns_query.o +dns_resolver-y := dns_query.o +dns_resolver_key-y := dns_key.o
net/dns_resolver/dns_key.c +9 -56
93 lines not on this page · raw message
net/dns_resolver/dns_query.c +64 -0
81 lines not on this page · raw message
net/dns_resolver/internal.h +0 -5
@@ -18,11 +18,6 @@ enum { dns_key_error, }; -/* -* dns_key.c -*/ -extern const struct cred *dns_resolver_cache; -/* * debug tracing */
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 02/13] dns_resolver: Move the key type into a separate module
Sashiko has reviewed this patch and found no issues.
Quoted 9 lines
Once keys pin to the kernel module of their key type, having the DNS key type in the same modules as the resolver will introduce a circular dependency preventing
module_exit()from ever running.Introduce dns_resolver_key.ko containing
key_type_dns_resolver. On a module exit, drop the credentials and callkey_gc_flush()in order the drain the remaining RCU callbacks.Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Jarkko Sakkinen
maintainerPATCH v6 3/13 NFSv4: Clear idmap keyring cache when the last client unloads
In reply to Jarkko Sakkinenid_resolver_cache->thread_keyring caches id_resolver_legacy keys up until nfs_idmap_quit() tears down the keyring.
Once keys pin to the kernel module of their key type, the cached keys prevent module_exit() from ever happening.
Track the active idmap instances under a mutex and clear the idmap cache keyring once the last client has been destroyed.
--- fs/nfs/nfs4idmap.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
fs/nfs/nfs4idmap.c +21 -0
@@ -47,6 +47,8 @@#include <keys/request_key_auth-type.h> #include <linux/module.h> #include <linux/user_namespace.h> +#include <linux/mutex.h> +#include <linux/ratelimit.h> #include "internal.h" #include "netns.h"
@@ -58,6 +60,10 @@static const struct cred *id_resolver_cache;static struct key_type key_type_id_resolver_legacy; +/* Serializes the idmap cache. */ +static DEFINE_MUTEX (nfs_idmap_cache_mutex); +static unsigned int nfs_idmap_users; +struct idmap_legacy_upcalldata {struct rpc_pipe_msg pipe_msg;struct idmap_msg idmap_msg;
@@ -469,7 +475,10 @@ nfs_idmap_new(struct nfs_client *clp)if (error) goto err_destroy_pipe; +mutex_lock (&nfs_idmap_cache_mutex); + nfs_idmap_users++; clp->cl_idmap = idmap; +mutex_unlock (&nfs_idmap_cache_mutex);return 0 ; err_destroy_pipe:rpc_destroy_pipe_data (idmap->idmap_pipe);
@@ -483,6 +492,7 @@ void nfs_idmap_delete(struct nfs_client *clp) {struct idmap *idmap = clp->cl_idmap; +int ret;if (!idmap)return ;
@@ -493,6 +503,17 @@ nfs_idmap_delete(struct nfs_client *clp)rpc_destroy_pipe_data (idmap->idmap_pipe);put_user_ns (idmap->user_ns);kfree (idmap); + +mutex_lock (&nfs_idmap_cache_mutex); +if (--nfs_idmap_users ==0 ) { + ret =keyring_clear (id_resolver_cache->thread_keyring); +if (ret) +pr_warn_ratelimited ("NFS: Failed to clear idmap cache: %d; cache pins remain\n" , + ret); +else +key_gc_flush (); + } +mutex_unlock (&nfs_idmap_cache_mutex); } static int nfs_idmap_prepare_message(char *desc, struct idmap *idmap,
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 03/13] NFSv4: Clear idmap keyring cache when the last client unloads
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
id_resolver_cache->thread_keyringcachesid_resolver_legacykeys up untilnfs_idmap_quit()tears down the keyring.Once keys pin to the kernel module of their key type, the cached keys prevent
module_exit()from ever happening.Track the active idmap instances under a mutex and clear the idmap cache keyring once the last client has been destroyed.
Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Jarkko Sakkinen
maintainerPATCH v6 4/13 smb: client: Clear idmap/SPNEGO caches when the last session is unloaded
In reply to Jarkko SakkinenCIFS caches cifs.idmap and cifs.spnego keys in the module-owned keyrings that are only destroyed in module_exit().
Once keys pin the kernel module of the key type, the cached entries will retain CIFS pinned after the last SMB session has been torned down.
Serialize the session count transitions with a mutex and clear the idmap and SPNEGO cache keyrings when the last session is freed.
--- fs/smb/client/cifs_spnego.c | 12 ++++++++++++ fs/smb/client/cifsacl.c | 12 ++++++++++++ fs/smb/client/cifsproto.h | 8 ++++++++ fs/smb/client/misc.c | 19 +++++++++++++++++-- 4 files changed, 49 insertions(+), 2 deletions(-)
fs/smb/client/cifs_spnego.c +12 -0
@@ -15,6 +15,7 @@#include <linux/key-type.h> #include <linux/keyctl.h> #include <linux/inet.h> +#include <linux/ratelimit.h> #include "cifsglob.h" #include "cifs_spnego.h" #include "cifs_debug.h"
@@ -190,6 +191,17 @@ cifs_get_spnego_key(struct cifs_ses *sesInfo,return spnego_key; } +void +cifs_spnego_clear_cache (void ) +{ +int ret; + + ret =keyring_clear (spnego_cred->thread_keyring); +if (ret) +pr_warn_ratelimited ("Failed to clear SPNEGO cache: %d; cache pins remain\n" , + ret); +} +int init_cifs_spnego (void ) {
fs/smb/client/cifsacl.c +12 -0
@@ -13,6 +13,7 @@#include <linux/string.h> #include <linux/keyctl.h> #include <linux/key-type.h> +#include <linux/ratelimit.h> #include <uapi/linux/posix_acl.h> #include <linux/posix_acl.h> #include <linux/posix_acl_xattr.h>
@@ -539,6 +540,17 @@ sid_to_id(struct cifs_sb_info *cifs_sb, struct smb_sid *psid,return 0 ; } +void +cifs_idmap_clear_cache (void ) +{ +int ret; + + ret =keyring_clear (root_cred->thread_keyring); +if (ret) +pr_warn_ratelimited ("Failed to clear idmap cache: %d; cache pins remain\n" , + ret); +} +int init_cifs_idmap (void ) {
fs/smb/client/cifsproto.h +8 -0
@@ -58,8 +58,16 @@ do { \ }while (0 ) int init_cifs_idmap(void);void exit_cifs_idmap (void ); +void cifs_idmap_clear_cache (void );int init_cifs_spnego (void );void exit_cifs_spnego (void ); +#ifdef CONFIG_CIFS_UPCALL +void cifs_spnego_clear_cache (void ); +#else +static inline void cifs_spnego_clear_cache (void ) +{ +} +#endif const char *build_path_from_dentry (struct dentry *direntry,void *page); char *__build_path_from_dentry_optional_prefix(struct dentry *direntry, void *page, const char *tree,
fs/smb/client/misc.c +17 -2
@@ -9,6 +9,8 @@#include <linux/slab.h> #include <linux/ctype.h> #include <linux/mempool.h> +#include <linux/key.h> +#include <linux/mutex.h> #include <linux/vmalloc.h> #include "cifsglob.h" #include "cifsproto.h"
@@ -33,6 +35,9 @@ struct tcon_list {struct cifs_tcon *tcon; }; +/* Serialize session admission with the last session's cache clear. */ +static DEFINE_MUTEX (cifs_session_mutex); +/* The xid serves as a useful identifier for each incoming vfs request, in a similar way to the mid which is useful to track each sent smb, and CurrentXid can also provide a running counter (although it
@@ -74,7 +79,6 @@ sesInfoAlloc(void) ret_buf = kzalloc_obj(struct cifs_ses);if (ret_buf) { -atomic_inc (&sesInfoAllocCount);spin_lock_init (&ret_buf->ses_lock); ret_buf->ses_status =SES_NEW ; ++ret_buf->ses_count;
@@ -84,6 +88,10 @@ sesInfoAlloc(void)spin_lock_init (&ret_buf->iface_lock);INIT_LIST_HEAD (&ret_buf->iface_list);spin_lock_init (&ret_buf->chan_lock); + +mutex_lock (&cifs_session_mutex); +atomic_inc (&sesInfoAllocCount); +mutex_unlock (&cifs_session_mutex); }return ret_buf; }
@@ -99,7 +107,6 @@ sesInfoFree(struct cifs_ses *buf_to_free) }unload_nls (buf_to_free->local_nls); -atomic_dec (&sesInfoAllocCount);kfree (buf_to_free->serverOS);kfree (buf_to_free->serverDomain);kfree (buf_to_free->serverNOS);
@@ -115,6 +122,14 @@ sesInfoFree(struct cifs_ses *buf_to_free)kref_put (&iface->refcount, release_iface);spin_unlock (&buf_to_free->iface_lock);kfree_sensitive (buf_to_free); + +mutex_lock (&cifs_session_mutex); +if (atomic_dec_and_test (&sesInfoAllocCount)) { +cifs_idmap_clear_cache (); +cifs_spnego_clear_cache (); +key_gc_flush (); + } +mutex_unlock (&cifs_session_mutex); } struct cifs_tcon *
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 04/13] smb: client: Clear idmap/SPNEGO caches when the last session is unloaded
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
CIFS caches cifs.idmap and cifs.spnego keys in the module-owned keyrings that are only destroyed in
module_exit().Once keys pin the kernel module of the key type, the cached entries will retain CIFS pinned after the last SMB session has been torned down.
Serialize the session count transitions with a mutex and clear the idmap and SPNEGO cache keyrings when the last session is freed.
Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
Jarkko Sakkinen
maintainerPATCH v6 5/13 s390/cert_store: Start tracking subsystem keys
In reply to Jarkko Sakkinencert_store refreshes its keyring by unregistering and then registering again key_type_cert_store_key. Once keys pin to the kernel module of their key type, this is no longer necessary.
Register key_type_cert_store_key once during init before creating sysfs attributes, and track subsystem-created keys explicitly so that the refresh operationunlinks and invalidates previous entries directly.
--- arch/s390/kernel/cert_store.c | 161 ++++++++++++++-------------------- 1 file changed, 67 insertions(+), 94 deletions(-)
arch/s390/kernel/cert_store.c +67 -94
@@ -17,6 +17,7 @@#include <linux/key.h> #include <linux/keyctl.h> #include <linux/kobject.h> +#include <linux/list.h> #include <linux/module.h> #include <linux/seq_file.h> #include <linux/slab.h>
@@ -296,6 +297,18 @@ static int check_certificate_valid(const struct vce *vce)return check_certificate_hash (vce); } +struct cert_store_key { +struct list_head list; +struct key *key; +}; + +static DEFINE_MUTEX (cs_refresh_lock); +/* Owned references, protected by cs_refresh_lock. */ +static LIST_HEAD (cs_keys); +static struct key *active_cs_keyring; +static struct key *cs_keyring_parent; + +/* Return an owned reference to the user session keyring. */ static struct key *get_user_session_keyring (void ) {key_ref_t us_keyring_ref;
@@ -305,118 +318,66 @@ static struct key *get_user_session_keyring(void)if (IS_ERR (us_keyring_ref)) {pr_dbf_msg ("Couldn't get user session keyring: %ld" ,PTR_ERR (us_keyring_ref)); -return ERR_PTR (-ENOKEY ); +return ERR_CAST (us_keyring_ref); } -key_ref_put (us_keyring_ref);return key_ref_to_ptr (us_keyring_ref); } -/* Invalidate all keys from cert_store keyring. */ -static int invalidate_keyring_keys (struct key *keyring) -{ -unsigned long num_keys, key_index; -size_t keyring_payload_len; -key_serial_t *key_array; -struct key *current_key; -int rc; - - keyring_payload_len = key_type_keyring.read (keyring,NULL ,0 ); - num_keys = keyring_payload_len /sizeof (key_serial_t); - key_array =kzalloc_objs (key_serial_t, num_keys); -if (!key_array) -return -ENOMEM ; - - rc = key_type_keyring.read (keyring, (char *)key_array, keyring_payload_len); -if (rc != keyring_payload_len) { -pr_dbf_msg ("Couldn't read keyring payload" ); - goto out; - } - -for (key_index =0 ; key_index < num_keys; key_index++) { - current_key =key_lookup (key_array[key_index]); -pr_dbf_msg ("Invalidating key %08x" , current_key->serial); - -key_invalidate (current_key); -key_put (current_key); - rc =key_unlink (keyring, current_key); -if (rc) { -pr_dbf_msg ("Couldn't unlink key %08x: %d" , current_key->serial, rc); -break ; - } - } -out: -kfree (key_array); -return rc; -} - -static struct key *find_cs_keyring (void ) -{ -key_ref_t cs_keyring_ref; -struct key *cs_keyring; - - cs_keyring_ref =keyring_search (make_key_ref (get_user_session_keyring (), true), - &key_type_keyring,CERT_STORE_KEYRING_NAME , - false); -if (!IS_ERR (cs_keyring_ref)) { - cs_keyring =key_ref_to_ptr (cs_keyring_ref); -key_ref_put (cs_keyring_ref); - goto found; - } -/* Search default locations: thread, process, session keyrings */ - cs_keyring =request_key (&key_type_keyring,CERT_STORE_KEYRING_NAME ,NULL ); -if (IS_ERR (cs_keyring)) -return NULL ; -key_put (cs_keyring); -found: -return cs_keyring; -} -static void cleanup_cs_keys (void ) { -struct key *cs_keyring; +struct cert_store_key *entry, *tmp; +int rc; - cs_keyring =find_cs_keyring (); -if (!cs_keyring) +if (!active_cs_keyring)return ; -pr_dbf_msg ("Found cert_store keyring. Purging..." ); -/* -* Remove cert_store_key_type in case invalidation -* of old cert_store keys failed (= severe error). -*/ -if (invalidate_keyring_keys (cs_keyring)) -unregister_key_type (&key_type_cert_store_key); +/* Invalidate even certificates unlinked or linked into other keyrings. */ +list_for_each_entry_safe (entry, tmp, &cs_keys, list) { +key_invalidate (entry->key); +key_put (entry->key); +list_del (&entry->list); +kfree (entry); + } -keyring_clear (cs_keyring); -key_invalidate (cs_keyring); -key_put (cs_keyring); -key_unlink (get_user_session_keyring (), cs_keyring); + rc =keyring_clear (active_cs_keyring); +if (rc) +pr_dbf_msg ("Couldn't clear cert_store keyring: %d" , rc); +key_invalidate (active_cs_keyring); + rc =key_unlink (cs_keyring_parent, active_cs_keyring); +if (rc) +pr_dbf_msg ("Couldn't unlink cert_store keyring: %d" , rc); +key_put (active_cs_keyring); +key_put (cs_keyring_parent); + active_cs_keyring =NULL ; + cs_keyring_parent =NULL ; } +/* Return a borrowed reference; cleanup_cs_keys() owns the keyring. */ static struct key *create_cs_keyring (void ) { -static struct key *cs_keyring; +struct key *cs_keyring, *parent;/* Cleanup previous cs_keyring and all associated keys if any. */ cleanup_cs_keys (); + parent =get_user_session_keyring (); +if (IS_ERR (parent)) +return parent; + cs_keyring =keyring_alloc (CERT_STORE_KEYRING_NAME ,GLOBAL_ROOT_UID ,GLOBAL_ROOT_GID ,current_cred (), (KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW |KEY_USR_READ ,KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_SET_KEEP , -NULL ,get_user_session_keyring ()); +NULL , parent);if (IS_ERR (cs_keyring)) {pr_dbf_msg ("Can't allocate cert_store keyring" ); -return NULL ; +key_put (parent); +return cs_keyring; } + active_cs_keyring = cs_keyring; + cs_keyring_parent = parent;pr_dbf_msg ("Successfully allocated cert_store keyring: %08x" , cs_keyring->serial); -/* -* In case a previous clean-up ran into an -* error and unregistered key type. -*/ -register_key_type (&key_type_cert_store_key); -return cs_keyring; }
@@ -454,6 +415,7 @@ static char *get_key_description(struct vcssb *vcssb, const struct vce *vce)static int create_key_from_vce (struct vcssb *vcssb,struct vce *vce,struct key *keyring) { +struct cert_store_key *entry;key_ref_t newkey;char *desc;int rc;
@@ -462,6 +424,13 @@ static int create_key_from_vce(struct vcssb *vcssb, struct vce *vce,if (!desc)return -ENOMEM ; +/* Reserve cleanup tracking before the key can be linked elsewhere. */ + entry =kmalloc_obj (*entry); +if (!entry) { + rc = -ENOMEM ; + goto out; + } + newkey = key_create_or_update( make_key_ref(keyring, true), CERT_STORE_KEY_TYPE_NAME, desc, (u8 *)vce + vce->vce_hdr.vc_offset,
@@ -473,10 +442,12 @@ static int create_key_from_vce(struct vcssb *vcssb, struct vce *vce,if (rc) {pr_dbf_msg ("Couldn't create a key from Certificate Entry (%d)" , rc); rc = -ENOKEY ; +kfree (entry); goto out; } -key_ref_put (newkey); + entry->key =key_ref_to_ptr (newkey); +list_add_tail (&entry->list, &cs_keys); out:kfree (desc);return rc;
@@ -704,19 +675,18 @@ static int fill_cs_keyring(void)if (rc) goto cleanup_keys; - rc = -ENOMEM ; cs_keyring =create_cs_keyring (); -if (!cs_keyring) +if (IS_ERR (cs_keyring)) { + rc =PTR_ERR (cs_keyring); goto cleanup_keys; + } rc =add_certificates_to_keyring (vcssb, cs_keyring);if (rc) - goto cleanup_cs_keyring; + goto cleanup_keys; goto out; -cleanup_cs_keyring: -key_put (cs_keyring); cleanup_keys:cleanup_cs_keys (); out:
@@ -724,7 +694,6 @@ static int fill_cs_keyring(void)return rc; } -static DEFINE_MUTEX (cs_refresh_lock);static int cs_status_val =-1 ; static ssize_t cs_status_show(struct kobject *kobj,
@@ -794,14 +763,18 @@ static int __init cert_store_init(void)if (!cert_store_kobj) goto cleanup_dbf; - rc =sysfs_create_files (cert_store_kobj, cert_store_attrs); + rc =register_key_type (&key_type_cert_store_key);if (rc) goto cleanup_kobj; -register_key_type (&key_type_cert_store_key); + rc =sysfs_create_files (cert_store_kobj, cert_store_attrs); +if (rc) + goto cleanup_key_type;return rc; +cleanup_key_type: +unregister_key_type (&key_type_cert_store_key); cleanup_kobj:kobject_put (cert_store_kobj); cleanup_dbf:
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 05/13] s390/cert_store: Start tracking subsystem keys
Sashiko has reviewed this patch and found no issues.
Quoted 9 lines
cert_storerefreshes its keyring by unregistering and then registering againkey_type_cert_store_key. Once keys pin to the kernel module of their key type, this is no longer necessary.Register
key_type_cert_store_keyonce during init before creating sysfs attributes, and track subsystem-created keys explicitly so that the refresh operationunlinks and invalidates previous entries directly.Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Jarkko Sakkinen
maintainerPATCH v6 6/13 KEYS: trusted: Update static calls before init
In reply to Jarkko SakkinenGiven that the static calls are updated only after ->init() returns, an added trusted key can race with the callback initializations. This can ultimately lead into null dereference as static_call() is used unchecked.
Address the bug by updating the static calls before invoking ->init(), and roll back on failure.
--- security/keys/trusted-keys/trusted_core.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
security/keys/trusted-keys/trusted_core.c +10 -5
@@ -373,14 +373,19 @@ static int __init init_trusted(void)if (!get_random) get_random = kernel_get_random; +static_call_update (trusted_key_seal, trusted_key_sources[i].ops->seal); +static_call_update (trusted_key_unseal, trusted_key_sources[i].ops->unseal); +static_call_update (trusted_key_get_random, get_random); + migratable = trusted_key_sources[i].ops->migratable; + ret = trusted_key_sources[i].ops->init ();if (!ret) { -static_call_update (trusted_key_seal, trusted_key_sources[i].ops->seal); -static_call_update (trusted_key_unseal, trusted_key_sources[i].ops->unseal); -static_call_update (trusted_key_get_random, get_random); - trusted_key_exit = trusted_key_sources[i].ops->exit; - migratable = trusted_key_sources[i].ops->migratable; + }else { +static_call_update (trusted_key_seal,NULL ); +static_call_update (trusted_key_unseal,NULL ); +static_call_update (trusted_key_get_random,NULL ); + migratable =0 ; }if (!ret || ret != -ENODEV )
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 06/13] KEYS: trusted: Update static calls before init
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
Given that the static calls are updated only after ->init() returns, an added trusted key can race with the callback initializations. This can ultimately lead into null dereference as
static_call()is used unchecked.Address the bug by updating the static calls before invoking ->init(), and roll back on failure.
Cc [email protected] # v5.15+Fixes 31de287345f4 ("KEYS: trusted: Rollback init_trusted() consistently")Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=6
Jarkko Sakkinen
maintainerPATCH v6 7/13 KEYS: trusted: TEE: Synchronize session lifetime
In reply to Jarkko SakkinenThe parent TEE device can remove the client device while live instances keep trusted.ko loaded.
Guard session context state with a mutex, publish pvt_data.dev before registering key_type_trusted and sanitize pvt_data on probe failure and removal.
When an active TEE has not been bound, reject seal, unseal and get_random with -ENODEV.
--- security/keys/trusted-keys/trusted_tee.c | 86 ++++++++++++++++++------ 1 file changed, 65 insertions(+), 21 deletions(-)
security/keys/trusted-keys/trusted_tee.c +65 -21
@@ -9,6 +9,7 @@#include <linux/err.h> #include <linux/key-type.h> #include <linux/module.h> +#include <linux/mutex.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/tee_drv.h>
@@ -56,6 +57,8 @@ struct trusted_key_tee_private { };static struct trusted_key_tee_private pvt_data; +/* Do not hold this mutex across key type registration or unregistration. */ +static DEFINE_MUTEX (trusted_key_tee_mutex);/* * Have the TEE seal(encrypt) the symmetric key
@@ -67,6 +70,12 @@ static int trusted_tee_seal(struct trusted_key_payload *p, char *datablob)struct tee_param param[4 ];struct tee_shm *reg_shm =NULL ; +mutex_lock (&trusted_key_tee_mutex); +if (!pvt_data.ctx) { + ret = -ENODEV ; + goto out_unlock; + } +memset (&inv_arg,0 ,sizeof (inv_arg));memset (¶m,0 ,sizeof (param));
@@ -74,7 +83,8 @@ static int trusted_tee_seal(struct trusted_key_payload *p, char *datablob) sizeof(p->key) + sizeof(p->blob));if (IS_ERR (reg_shm)) {dev_err (pvt_data.dev,"shm register failed\n" ); -return PTR_ERR (reg_shm); + ret =PTR_ERR (reg_shm); + goto out_unlock; } inv_arg.func =TA_CMD_SEAL ;
@@ -100,7 +110,8 @@ static int trusted_tee_seal(struct trusted_key_payload *p, char *datablob) }tee_shm_free (reg_shm); - +out_unlock: +mutex_unlock (&trusted_key_tee_mutex);return ret; }
@@ -114,6 +125,12 @@ static int trusted_tee_unseal(struct trusted_key_payload *p, char *datablob)struct tee_param param[4 ];struct tee_shm *reg_shm =NULL ; +mutex_lock (&trusted_key_tee_mutex); +if (!pvt_data.ctx) { + ret = -ENODEV ; + goto out_unlock; + } +memset (&inv_arg,0 ,sizeof (inv_arg));memset (¶m,0 ,sizeof (param));
@@ -121,7 +138,8 @@ static int trusted_tee_unseal(struct trusted_key_payload *p, char *datablob) sizeof(p->key) + sizeof(p->blob));if (IS_ERR (reg_shm)) {dev_err (pvt_data.dev,"shm register failed\n" ); -return PTR_ERR (reg_shm); + ret =PTR_ERR (reg_shm); + goto out_unlock; } inv_arg.func =TA_CMD_UNSEAL ;
@@ -147,7 +165,8 @@ static int trusted_tee_unseal(struct trusted_key_payload *p, char *datablob) }tee_shm_free (reg_shm); - +out_unlock: +mutex_unlock (&trusted_key_tee_mutex);return ret; }
@@ -161,13 +180,20 @@ static int trusted_tee_get_random(unsigned char *key, size_t key_len)struct tee_param param[4 ];struct tee_shm *reg_shm =NULL ; +mutex_lock (&trusted_key_tee_mutex); +if (!pvt_data.ctx) { + ret = -ENODEV ; + goto out_unlock; + } +memset (&inv_arg,0 ,sizeof (inv_arg));memset (¶m,0 ,sizeof (param)); reg_shm =tee_shm_register_kernel_buf (pvt_data.ctx, key, key_len);if (IS_ERR (reg_shm)) {dev_err (pvt_data.dev,"key shm register failed\n" ); -return PTR_ERR (reg_shm); + ret =PTR_ERR (reg_shm); + goto out_unlock; } inv_arg.func =TA_CMD_GET_RANDOM ;
@@ -189,7 +215,8 @@ static int trusted_tee_get_random(unsigned char *key, size_t key_len) }tee_shm_free (reg_shm); - +out_unlock: +mutex_unlock (&trusted_key_tee_mutex);return ret; }
@@ -205,50 +232,67 @@ static int optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data)static int trusted_key_probe (struct tee_client_device *rng_device) {struct device *dev = &rng_device->dev; +struct tee_context *ctx;int ret;struct tee_ioctl_open_session_arg sess_arg; +mutex_lock (&trusted_key_tee_mutex); +if (pvt_data.ctx) { + ret = -EBUSY ; + goto out_unlock; + } +memset (&sess_arg,0 ,sizeof (sess_arg)); - pvt_data.ctx =tee_client_open_context (NULL , optee_ctx_match,NULL , -NULL ); -if (IS_ERR (pvt_data.ctx)) -return -ENODEV ; + ctx =tee_client_open_context (NULL , optee_ctx_match,NULL ,NULL ); +if (IS_ERR (ctx)) { + ret = -ENODEV ; + goto out_unlock; + }memcpy (sess_arg.uuid, rng_device->id.uuid.b,TEE_IOCTL_UUID_LEN ); sess_arg.clnt_login =TEE_IOCTL_LOGIN_REE_KERNEL ; sess_arg.num_params =0 ; - ret =tee_client_open_session (pvt_data.ctx, &sess_arg,NULL ); + ret =tee_client_open_session (ctx, &sess_arg,NULL );if ((ret <0 ) || (sess_arg.ret !=0 )) {dev_err (dev,"tee_client_open_session failed, err: %x\n" , sess_arg.ret); ret = -EINVAL ; goto out_ctx; } + pvt_data.ctx = ctx; pvt_data.session_id = sess_arg.session; - - ret =register_key_type (&key_type_trusted); -if (ret <0 ) - goto out_sess; - pvt_data.dev = dev; +mutex_unlock (&trusted_key_tee_mutex); -return 0 ; + ret =register_key_type (&key_type_trusted); +if (!ret) +return 0 ; -out_sess: -tee_client_close_session (pvt_data.ctx, pvt_data.session_id); +mutex_lock (&trusted_key_tee_mutex); +tee_client_close_session (ctx, pvt_data.session_id); out_ctx: -tee_client_close_context (pvt_data.ctx); - +tee_client_close_context (ctx); + pvt_data.ctx =NULL ; + pvt_data.dev =NULL ; + pvt_data.session_id =0 ; +out_unlock: +mutex_unlock (&trusted_key_tee_mutex);return ret; }static void trusted_key_remove (struct tee_client_device *dev) {unregister_key_type (&key_type_trusted); + +mutex_lock (&trusted_key_tee_mutex);tee_client_close_session (pvt_data.ctx, pvt_data.session_id);tee_client_close_context (pvt_data.ctx); + pvt_data.ctx =NULL ; + pvt_data.dev =NULL ; + pvt_data.session_id =0 ; +mutex_unlock (&trusted_key_tee_mutex); }static const struct tee_client_device_id trusted_key_id_table[] = {
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 07/13] KEYS: trusted: TEE: Synchronize session lifetime
Sashiko has reviewed this patch and found no issues.
Quoted 7 lines
The parent TEE device can remove the client device while live instances keep trusted.ko loaded.
Guard session context state with a mutex, publish pvt_data.dev before registering
key_type_trustedand sanitizepvt_dataon probe failure and removal.
Quoted 7 lines
When an active TEE has not been bound, reject seal, unseal and
get_randomwith-ENODEV.Cc [email protected] # v5.15+Fixes 0a95ebc91305 ("KEYS: trusted: Introduce TEE based Trusted Keys")Reviewed-by Sumit Garg <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Jarkko Sakkinen
maintainerPATCH v6 8/13 KEYS: trusted: TEE: Disable sysfs bind attributes
In reply to Jarkko SakkinenSuppress sysfs bind and unbind attributes on trusted_key_driver so that userspace cannot unbind the driver and unregister key_type_trusted while the trusted module remains loaded.
--- security/keys/trusted-keys/trusted_tee.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
security/keys/trusted-keys/trusted_tee.c +2 -1
@@ -307,7 +307,8 @@ static struct tee_client_driver trusted_key_driver = { .remove = trusted_key_remove, .id_table = trusted_key_id_table, .driver = { - .name = DRIVER_NAME, + .name = DRIVER_NAME, + .suppress_bind_attrs = true, }, };
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 08/13] KEYS: trusted: TEE: Disable sysfs bind attributes
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Suppress sysfs bind and unbind attributes on
trusted_key_driverso that userspace cannot unbind the driver and unregisterkey_type_trustedwhile the trusted module remains loaded.Reviewed-by Sumit Garg <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Jarkko Sakkinen
maintainerPATCH v6 9/13 rxrpc: Release conn->key when init_connection_security() fails
In reply to Jarkko SakkinenClear conn->key before calling key_put() when init_connection_security() fails, and pair with READ_ONCE() in rxrpc_connection_seq_show().
--- net/rxrpc/conn_event.c | 7 ++++++- net/rxrpc/proc.c | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-)
net/rxrpc/conn_event.c +6 -1
@@ -298,8 +298,13 @@ static int rxrpc_process_event(struct rxrpc_connection *conn, ret = conn->security->init_connection_security ( conn, conn->key->payload.data[0 ]); -if (ret <0 ) +if (ret <0 ) { +struct key *key = conn->key; + +WRITE_ONCE (conn->key,NULL ); +key_put (key);return ret; + }spin_lock_irq (&conn->state_lock);if (conn->state ==RXRPC_CONN_SERVICE_CHALLENGING ) {
net/rxrpc/proc.c +1 -1
@@ -182,7 +182,7 @@ static int rxrpc_connection_seq_show(struct seq_file *seq, void *v)refcount_read (&conn->ref),atomic_read (&conn->active), state, -key_serial (conn->key), +key_serial (READ_ONCE (conn->key)), conn->tx_serial, conn->hi_serial, conn->channels[0].call_id,
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 09/13] rxrpc: Release conn->key when init_connection_security() fails
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Clear
conn->keybefore callingkey_put()wheninit_connection_security()fails, and pair withREAD_ONCE()inrxrpc_connection_seq_show().Fixes 17926a79320a ("[AF_RXRPC]: Provide secure RxRPC sockets for use by userspace and kernel both")Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
Jarkko Sakkinen
maintainerPATCH v6 10/13 rxrpc: Move key types to their own module
In reply to Jarkko SakkinenOnce keys pin the kernel module implementing their key type, hosting rxrpc and rxrpc_s keys inside the same module prevents unloading the transport module while keys remain in keyrings or cached connections.
Split the key types and their preparse logic into a separate rxrpc_keys.ko module that rxrpc.ko depends on, and flush key GC on rxrpc exit.
By doing this, rxrpc.ko can be removed while the persistent keys pin only rxrpc_keys.ko.
--- Documentation/networking/rxrpc.rst | 2 +- net/Makefile | 2 +- net/rxrpc/Kconfig | 20 +++ net/rxrpc/Makefile | 7 +- net/rxrpc/af_rxrpc.c | 19 +-- net/rxrpc/ar-internal.h | 25 +-- net/rxrpc/key.c | 122 +++++--------- net/rxrpc/rxgk.c | 66 -------- net/rxrpc/rxkad.c | 47 ------ net/rxrpc/security.c | 184 ++++++++++++++++++++ net/rxrpc/server_key.c | 260 +++++++++++++++++------------ 11 files changed, 411 insertions(+), 343 deletions(-)
Documentation/networking/rxrpc.rst +1 -1
@@ -1165,5 +1165,5 @@ API Function Reference .. kernel-doc:: net/rxrpc/recvmsg.c .. kernel-doc:: net/rxrpc/rxgk.c .. kernel-doc:: net/rxrpc/rxkad.c +.. kernel-doc:: net/rxrpc/security.c .. kernel-doc:: net/rxrpc/sendmsg.c -.. kernel-doc:: net/rxrpc/server_key.c
net/Makefile +1 -1
@@ -30,7 +30,7 @@ obj-$(CONFIG_LAPB) += lapb/ obj-$(CONFIG_CAN) += can/ obj-$(CONFIG_BT) += bluetooth/ obj-$(CONFIG_SUNRPC) += sunrpc/ -obj-$(CONFIG_AF_RXRPC) += rxrpc/ +obj-$(CONFIG_RXRPC_KEYS) += rxrpc/ obj-$(CONFIG_AF_KCM) += kcm/ obj-$(CONFIG_STREAM_PARSER) += strparser/ obj-$(CONFIG_ATM) += atm/
net/rxrpc/Kconfig +20 -0
@@ -3,6 +3,18 @@ # RxRPC session sockets # +config RXRPC_KEYS + tristate "RxRPC key types" + select CRYPTO + select CRYPTO_LIB_DES if RXKAD + select KEYS + help + Say Y or M here to include support for rxrpc and rxrpc_s key types + independently of RxRPC session sockets. + + To compile this as a module, choose M here: the module will be called + rxrpc_keys. + config AF_RXRPC tristate "RxRPC session sockets" depends on INET
@@ -10,6 +22,7 @@ config AF_RXRPC select CRYPTO_LIB_DES if RXKAD select KEYS select NET_UDP_TUNNEL + select RXRPC_KEYS help Say Y or M here to include support for RxRPC session sockets (just the transport part, not the presentation part: (un)marshalling is
@@ -54,6 +67,9 @@ config AF_RXRPC_DEBUG See Documentation/networking/rxrpc.rst. +endif + +if RXRPC_KEYS config RXKAD bool "RxRPC Kerberos security"
@@ -86,6 +102,10 @@ config RXGK See Documentation/networking/rxrpc.rst. +endif + +if AF_RXRPC + config RXPERF tristate "RxRPC test service" help
net/rxrpc/Makefile +5 -2
@@ -3,6 +3,7 @@ # Makefile for Linux kernel RxRPC # +obj-$(CONFIG_RXRPC_KEYS) += rxrpc_keys.o obj-$(CONFIG_AF_RXRPC) += rxrpc.o rxrpc-y := \
@@ -19,7 +20,6 @@ rxrpc-y := \ input_rack.o \ insecure.o \ io_thread.o \ - key.o \ local_event.o \ local_object.o \ misc.o \
@@ -32,7 +32,6 @@ rxrpc-y := \ rtt.o \ security.o \ sendmsg.o \ - server_key.o \ skbuff.o \ txbuf.o \ utils.o
@@ -45,5 +44,9 @@ rxrpc-$(CONFIG_RXGK) += \ rxgk_app.o \ rxgk_kdf.o +rxrpc_keys-y := \ + key.o \ + server_key.o + obj-$(CONFIG_RXPERF) += rxperf.o obj-$(CONFIG_KUNIT) += tests/
net/rxrpc/af_rxrpc.c +1 -18
@@ -1077,18 +1077,6 @@ static int __init af_rxrpc_init(void) goto error_sock; } - ret =register_key_type (&key_type_rxrpc); -if (ret <0 ) { -pr_crit ("Cannot register client key type\n" ); - goto error_key_type; - } - - ret =register_key_type (&key_type_rxrpc_s); -if (ret <0 ) { -pr_crit ("Cannot register server key type\n" ); - goto error_key_type_s; - } - ret =rxrpc_sysctl_init ();if (ret <0 ) {pr_crit ("Cannot register sysctls\n" );
@@ -1098,10 +1086,6 @@ static int __init af_rxrpc_init(void)return 0 ; error_sysctls: -unregister_key_type (&key_type_rxrpc_s); -error_key_type_s: -unregister_key_type (&key_type_rxrpc); -error_key_type:sock_unregister (PF_RXRPC ); error_sock:proto_unregister (&rxrpc_proto);
@@ -1124,8 +1108,6 @@ static void __exit af_rxrpc_exit(void) {_enter ("" );rxrpc_sysctl_exit (); -unregister_key_type (&key_type_rxrpc_s); -unregister_key_type (&key_type_rxrpc);sock_unregister (PF_RXRPC );proto_unregister (&rxrpc_proto);unregister_pernet_device (&rxrpc_net_ops);
@@ -1139,6 +1121,7 @@ static void __exit af_rxrpc_exit(void)destroy_workqueue (rxrpc_workqueue);rxrpc_exit_security ();kmem_cache_destroy (rxrpc_call_jar); +key_gc_flush ();_leave ("" ); }
net/rxrpc/ar-internal.h +6 -19
@@ -273,18 +273,6 @@ struct rxrpc_security {/* Clean up a security service */ void (*exit)(void ); -/* Parse the information from a server key */ -int (*preparse_server_key)(struct key_preparsed_payload *); - -/* Clean up the preparse buffer after parsing a server key */ -void (*free_preparse_server_key)(struct key_preparsed_payload *); - -/* Destroy the payload of a server key */ -void (*destroy_server_key)(struct key *); - -/* Describe a server key */ -void (*describe_server_key)(const struct key *,struct seq_file *); -/* initialise a connection's security */ int (*init_connection_security)(struct rxrpc_connection *,struct rxrpc_key_token *);
@@ -1307,10 +1295,6 @@ extern const struct rxrpc_security rxrpc_no_security;*/ extern struct key_type key_type_rxrpc; -int rxrpc_request_key (struct rxrpc_sock *,sockptr_t ,int ); -int rxrpc_get_server_data_key (struct rxrpc_connection *,const void *,time64_t , -u32 ); -/* * local_event.c */
@@ -1492,6 +1476,11 @@ const struct rxrpc_security *rxrpc_get_incoming_security(struct rxrpc_sock *, struct sk_buff *);struct key *rxrpc_look_up_server_security (struct rxrpc_connection *,struct sk_buff *,u32 ,u32 ); +int rxrpc_request_key (struct rxrpc_sock *rx,sockptr_t optval,int optlen); +int rxrpc_get_server_data_key (struct rxrpc_connection *conn, +const void *session_key,time64_t expiry, +u32 kvno); +int rxrpc_server_keyring (struct rxrpc_sock *rx,sockptr_t optval,int optlen);/* * sendmsg.c
@@ -1505,8 +1494,6 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *, struct msghdr *, size_t);*/ extern struct key_type key_type_rxrpc_s; -int rxrpc_server_keyring (struct rxrpc_sock *,sockptr_t ,int ); -/* * skbuff.c */
@@ -1633,7 +1620,7 @@ extern unsigned int rxrpc_debug;#define _leave (FMT ,...) kleave(FMT,##__VA_ARGS__)#define _debug (FMT ,...) kdebug(FMT,##__VA_ARGS__) -#elif defined(CONFIG_AF_RXRPC_DEBUG ) +#elif defined(CONFIG_AF_RXRPC_DEBUG ) && !defined(RXRPC_KEY_PROVIDER )#define RXRPC_DEBUG_KENTER 0x01#define RXRPC_DEBUG_KLEAVE 0x02#define RXRPC_DEBUG_KDEBUG 0x04
net/rxrpc/key.c +39 -83
137 lines not on this page · raw message
net/rxrpc/rxgk.c +0 -66
78 lines not on this page · raw message
net/rxrpc/rxkad.c +0 -47
59 lines not on this page · raw message
net/rxrpc/security.c +184 -0
193 lines not on this page · raw message
net/rxrpc/server_key.c +154 -106
322 lines not on this page · raw message
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 10/13] rxrpc: Move key types to their own module
Sashiko has reviewed this patch and found no issues.
Quoted 7 lines
Once keys pin the kernel module implementing their key type, hosting rxrpc and
rxrpc_skeys inside the same module prevents unloading the transport module while keys remain in keyrings or cached connections.Split the key types and their preparse logic into a separate rxrpc_keys.ko module that rxrpc.ko depends on, and flush key GC on rxrpc exit.
Quoted 6 lines
By doing this, rxrpc.ko can be removed while the persistent keys pin only rxrpc_keys.ko.
Co-developed-by David Howells <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=10
Jarkko Sakkinen
maintainerPATCH v6 11/13 KEYS: Pin the backing kernel module for a key type
In reply to Jarkko SakkinenAdd the owner field (populated with THIS_MODULE) to struct key_type.
Pin the module in key_alloc() and keyring_restrict(), and release it in key_gc_unused_keys() and keyring_destroy(), which are wires to the keys and restrictions.
Reject module owners still in MODULE_STATE_COMING so that the failed module_init() paths cannot leave behind referenced keys.
--- include/linux/key-type.h | 6 ++++- security/keys/gc.c | 14 ++++++++++-- security/keys/key.c | 48 ++++++++++++++++++++++++++++++---------- security/keys/keyring.c | 36 +++++++++++++++++++++++++----- 4 files changed, 83 insertions(+), 21 deletions(-)
include/linux/key-type.h +5 -1
@@ -10,9 +10,11 @@#include <linux/key.h> #include <linux/errno.h> +#include <linux/init.h> #ifdef CONFIG_KEYS +struct module ;struct kernel_pkey_query ;struct kernel_pkey_params ;
@@ -161,6 +163,7 @@ struct key_type { const void *in, const void *in2);/* internal fields */ +struct module *owner;atomic64_t index_id;/* Opaque keyring index ID */ struct list_head link;/* link in types list */ struct lock_class_key lock_class;/* key->sem lock class */
@@ -168,7 +171,8 @@ struct key_type {extern struct key_type key_type_keyring; -extern int register_key_type (struct key_type *ktype); +int __register_key_type (struct key_type *ktype,struct module *owner); +#define register_key_type (ktype) __register_key_type(ktype, THIS_MODULE)extern void unregister_key_type (struct key_type *ktype);extern int key_payload_reserve (struct key *key,size_t datalen);
security/keys/gc.c +12 -2
@@ -6,6 +6,7 @@*/ #include <linux/slab.h> +#include <linux/module.h> #include <linux/security.h> #include <keys/keyring-type.h> #include "internal.h"
@@ -150,6 +151,7 @@ static noinline void key_gc_unused_keys(struct list_head *keys)while (!list_empty (keys)) {struct key *key = list_entry(keys->next, struct key, graveyard_link); +struct module *owner = key->type->owner;short state = key->state;list_del (&key->graveyard_link);
@@ -163,8 +165,15 @@ static noinline void key_gc_unused_keys(struct list_head *keys)#endif /* Throw away the key data if the key is instantiated */ -if (state ==KEY_IS_POSITIVE && key->type->destroy) - key->type->destroy (key); +if (state ==KEY_IS_POSITIVE ) { +if (key->type->destroy) + key->type->destroy (key); + }else if (key->restrict_link) { +if (key->restrict_link->keytype) +module_put (key->restrict_link->keytype->owner); +key_put (key->restrict_link->key); +kfree (key->restrict_link); + }security_key_free (key);
@@ -178,6 +187,7 @@ static noinline void key_gc_unused_keys(struct list_head *keys)memzero_explicit (key,sizeof (*key));kmem_cache_free (key_jar, key); +module_put (owner); } }
security/keys/key.c +36 -12
115 lines not on this page · raw message
security/keys/keyring.c +30 -6
@@ -7,6 +7,7 @@#include <linux/export.h> #include <linux/init.h> +#include <linux/module.h> #include <linux/sched.h> #include <linux/slab.h> #include <linux/security.h>
@@ -436,6 +437,9 @@ static void keyring_destroy(struct key *keyring)if (keyring->restrict_link) {struct key_restriction *keyres = keyring->restrict_link; +if (keyres->keytype) +module_put (keyres->keytype->owner); +key_put (keyres->key);kfree (keyres); }
@@ -540,6 +544,9 @@ struct key *keyring_alloc(const char *description, kuid_t uid, kgid_t gid,if (!IS_ERR (keyring)) { ret =key_instantiate_and_link (keyring,NULL ,0 , dest,NULL );if (ret <0 ) { +if (restrict_link && restrict_link->keytype) +module_put (restrict_link->keytype->owner); + keyring->restrict_link =NULL ;key_put (keyring); keyring =ERR_PTR (ret); }
@@ -1062,7 +1069,7 @@ int keyring_restrict(key_ref_t keyring_ref, const char *type,if (!restrict_type->lookup_restriction) { ret = -ENOENT ; - goto error; + goto out; } restrict_link = restrict_type->lookup_restriction (restriction);
@@ -1070,7 +1077,15 @@ int keyring_restrict(key_ref_t keyring_ref, const char *type,if (IS_ERR (restrict_link)) { ret =PTR_ERR (restrict_link); - goto error; + goto out; + } + +if (restrict_link && restrict_link->keytype && + ((restrict_link->keytype->owner && +module_is_coming (restrict_link->keytype->owner)) || + !try_module_get (restrict_link->keytype->owner))) { + ret = -ENOENT ; + goto out_free_restriction; }down_write (&keyring->sem);
@@ -1088,12 +1103,21 @@ int keyring_restrict(key_ref_t keyring_ref, const char *type,up_write (&keyring_serialise_restrict_sem);up_write (&keyring->sem); -if (ret <0 ) { +if (ret <0 ) + goto out_put_module; + + goto out; + +out_put_module: +if (restrict_link && restrict_link->keytype) +module_put (restrict_link->keytype->owner); + +out_free_restriction: +if (restrict_link)key_put (restrict_link->key); -kfree (restrict_link); - } +kfree (restrict_link); -error: +out:if (restrict_type)key_type_put (restrict_type);
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 11/13] KEYS: Pin the backing kernel module for a key type
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
Add the owner field (populated with
THIS_MODULE) to structkey_type.Pin the module in
key_alloc()andkeyring_restrict(), and release it inkey_gc_unused_keys()andkeyring_destroy(), which are wires to the keys and restrictions.Reject module owners still in
MODULE_STATE_COMINGso that the failedmodule_init()paths cannot leave behind referenced keys.Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
Jarkko Sakkinen
maintainerPATCH v6 12/13 KEYS: Remove key_type_dead
In reply to Jarkko Sakkinenunregister_key_type() no longer needs to retype live keys as keys and restrictions pin the module while they reference it.
Remove key_type_dead and associated code from the keyring GC.
--- security/keys/gc.c | 136 ++------------------------------------- security/keys/internal.h | 4 -- security/keys/key.c | 9 +-- security/keys/keyring.c | 50 -------------- 4 files changed, 9 insertions(+), 190 deletions(-)
security/keys/gc.c +7 -129
@@ -42,22 +42,8 @@ static void key_gc_timer_func(struct timer_list *); static DEFINE_TIMER(key_gc_timer, key_gc_timer_func);static time64_t key_gc_next_run =TIME64_MAX ; -static struct key_type *key_gc_dead_keytype; -static unsigned long key_gc_flags;#define KEY_GC_KEY_EXPIRED 0/* A key expired and needs unlinking */ -#define KEY_GC_REAP_KEYTYPE 1/* A keytype is being unregistered */ -#define KEY_GC_REAPING_KEYTYPE 2/* Cleared when keytype reaped */ - - -/* -* Any key whose type gets unregistered will be re-typed to this if it can't be -* immediately unlinked. -*/ -struct key_type key_type_dead = { - .name =".dead" , -}; -/* * Schedule a garbage collection run. * - time precision isn't particularly important
@@ -69,7 +55,7 @@ void key_schedule_gc(time64_t gc_at)kenter ("%lld" , gc_at - now); -if (gc_at <= now ||test_bit (KEY_GC_REAP_KEYTYPE , &key_gc_flags)) { +if (gc_at <= now) {kdebug ("IMMEDIATE" );queue_work (key_gc_wq, &key_gc_work); }else if (gc_at < key_gc_next_run) {
@@ -113,36 +99,6 @@ static void key_gc_timer_func(struct timer_list *unused)key_schedule_gc_links (); } -/* -* Reap keys of dead type. -* -* We use three flags to make sure we see three complete cycles of the garbage -* collector: the first to mark keys of that type as being dead, the second to -* collect dead links and the third to clean up the dead keys. We have to be -* careful as there may already be a cycle in progress. -* -* The caller must be holding key_types_sem. -*/ -void key_gc_keytype (struct key_type *ktype) -{ -kenter ("%s" , ktype->name); - - key_gc_dead_keytype = ktype; -set_bit (KEY_GC_REAPING_KEYTYPE , &key_gc_flags); -smp_mb (); -set_bit (KEY_GC_REAP_KEYTYPE , &key_gc_flags); - -kdebug ("schedule" ); -queue_work (key_gc_wq, &key_gc_work); - -kdebug ("sleep" ); -wait_on_bit (&key_gc_flags,KEY_GC_REAPING_KEYTYPE , -TASK_UNINTERRUPTIBLE ); - - key_gc_dead_keytype =NULL ; -kleave ("" ); -} -/* * Garbage collect a list of unreferenced, detached keys */
@@ -201,30 +157,20 @@ static noinline void key_gc_unused_keys(struct list_head *keys)static void key_garbage_collector (struct work_struct *work) {static LIST_HEAD (graveyard); -static u8 gc_state;/* Internal persistent state */ +u8 gc_state =0 ;#define KEY_GC_REAP_AGAIN 0x01/* - Need another cycle */ #define KEY_GC_REAPING_LINKS 0x02/* - We need to reap links */ -#define KEY_GC_REAPING_DEAD_1 0x10/* - We need to mark dead keys */ -#define KEY_GC_REAPING_DEAD_2 0x20/* - We need to reap dead key links */ -#define KEY_GC_REAPING_DEAD_3 0x40/* - We need to reap dead keys */ -#define KEY_GC_FOUND_DEAD_KEY 0x80/* - We found at least one dead key */ struct rb_node *cursor;struct key *key;time64_t new_timer, limit, expiry; -kenter ("[%lx,%x]" , key_gc_flags, gc_state); +kenter ("[%lx]" , key_gc_flags); limit =ktime_get_real_seconds (); -/* Work out what we're going to be doing in this pass */ - gc_state &=KEY_GC_REAPING_DEAD_1 |KEY_GC_REAPING_DEAD_2 ; - gc_state <<=1 ;if (test_and_clear_bit (KEY_GC_KEY_EXPIRED , &key_gc_flags)) gc_state |=KEY_GC_REAPING_LINKS ; - -if (test_and_clear_bit (KEY_GC_REAP_KEYTYPE , &key_gc_flags)) - gc_state |=KEY_GC_REAPING_DEAD_1 ;kdebug ("new pass %x" , gc_state); new_timer =TIME64_MAX ;
@@ -246,18 +192,6 @@ static void key_garbage_collector(struct work_struct *work) goto found_unreferenced_key; } -if (unlikely (gc_state &KEY_GC_REAPING_DEAD_1 )) { -if (key->type == key_gc_dead_keytype) { - gc_state |=KEY_GC_FOUND_DEAD_KEY ; -set_bit (KEY_FLAG_DEAD , &key->flags); - key->perm =0 ; - goto skip_dead_key; - }else if (key->type == &key_type_keyring && - key->restrict_link) { - goto found_restricted_keyring; - } - } - expiry = key->expiry;if (expiry !=TIME64_MAX ) {if (!(key->type->flags &KEY_TYPE_INSTANT_REAP ))
@@ -269,21 +203,10 @@ static void key_garbage_collector(struct work_struct *work) } } -if (unlikely (gc_state &KEY_GC_REAPING_DEAD_2 )) -if (key->type == key_gc_dead_keytype) - gc_state |=KEY_GC_FOUND_DEAD_KEY ; - -if ((gc_state &KEY_GC_REAPING_LINKS ) || -unlikely (gc_state &KEY_GC_REAPING_DEAD_2 )) { -if (key->type == &key_type_keyring) - goto found_keyring; - } - -if (unlikely (gc_state &KEY_GC_REAPING_DEAD_3 )) -if (key->type == key_gc_dead_keytype) - goto destroy_dead_key; +if ((gc_state &KEY_GC_REAPING_LINKS ) && + key->type == &key_type_keyring) + goto found_keyring; - skip_dead_key:if (spin_is_contended (&key_serial_lock) ||need_resched ()) goto contended; }
@@ -309,8 +232,7 @@ static void key_garbage_collector(struct work_struct *work)key_schedule_gc (new_timer); } -if (unlikely (gc_state &KEY_GC_REAPING_DEAD_2 ) || - !list_empty (&graveyard)) { +if (!list_empty (&graveyard)) {/* Make sure that all pending keyring payload destructions are * fulfilled and that people aren't now looking at dead or * dying keys that they don't have a reference upon or a link
@@ -318,32 +240,10 @@ static void key_garbage_collector(struct work_struct *work)*/ kdebug ("gc sync" );synchronize_rcu (); - } - -if (!list_empty (&graveyard)) {kdebug ("gc keys" );key_gc_unused_keys (&graveyard); } -if (unlikely (gc_state & (KEY_GC_REAPING_DEAD_1 | -KEY_GC_REAPING_DEAD_2 ))) { -if (!(gc_state &KEY_GC_FOUND_DEAD_KEY )) { -/* No remaining dead keys: short circuit the remaining -* keytype reap cycles. -*/ -kdebug ("dead short" ); - gc_state &= ~(KEY_GC_REAPING_DEAD_1 |KEY_GC_REAPING_DEAD_2 ); - gc_state |=KEY_GC_REAPING_DEAD_3 ; - }else { - gc_state |=KEY_GC_REAP_AGAIN ; - } - } - -if (unlikely (gc_state &KEY_GC_REAPING_DEAD_3 )) { -kdebug ("dead wake" ); -clear_and_wake_up_bit (KEY_GC_REAPING_KEYTYPE , &key_gc_flags); - } -if (gc_state &KEY_GC_REAP_AGAIN )queue_work (key_gc_wq, &key_gc_work);kleave (" [end %x]" , gc_state);
@@ -361,14 +261,6 @@ static void key_garbage_collector(struct work_struct *work) gc_state |=KEY_GC_REAP_AGAIN ; goto maybe_resched; -/* We found a restricted keyring and need to update the restriction if -* it is associated with the dead key type. -*/ -found_restricted_keyring: -spin_unlock (&key_serial_lock); -keyring_restriction_gc (key, key_gc_dead_keytype); - goto maybe_resched; -/* We found a keyring and we need to check the payload for links to * dead or expired keys. We don't flag another reap immediately as we * have to wait for the old payload to be destroyed by RCU before we
@@ -378,18 +270,4 @@ static void key_garbage_collector(struct work_struct *work)spin_unlock (&key_serial_lock);keyring_gc (key, limit); goto maybe_resched; - -/* We found a dead key that is still referenced. Reset its type and -* destroy its payload with its semaphore held. -*/ -destroy_dead_key: -spin_unlock (&key_serial_lock); -kdebug ("destroy key %d" , key->serial); -down_write (&key->sem); - key->type = &key_type_dead; -if (key_gc_dead_keytype->destroy) - key_gc_dead_keytype->destroy (key); -memset (&key->payload,KEY_DESTROY ,sizeof (key->payload)); -up_write (&key->sem); - goto maybe_resched; }
security/keys/internal.h +0 -4
@@ -38,7 +38,6 @@ struct iovec; no_printk(KERN_DEBUG FMT"\n", ##__VA_ARGS__)#endif -extern struct key_type key_type_dead;extern struct key_type key_type_user;extern struct key_type key_type_logon;
@@ -166,12 +165,9 @@ extern struct work_struct key_gc_work;extern unsigned key_gc_delay;extern struct workqueue_struct *key_gc_wq;extern void keyring_gc (struct key *keyring,time64_t limit); -extern void keyring_restriction_gc (struct key *keyring, -struct key_type *dead_type);void key_set_expiry (struct key *key,time64_t expiry);extern void key_schedule_gc (time64_t gc_at);extern void key_schedule_gc_links (void ); -extern void key_gc_keytype (struct key_type *ktype); extern int key_task_permission(const key_ref_t key_ref, const struct cred *cred,
security/keys/key.c +2 -7
@@ -1294,18 +1294,14 @@ EXPORT_SYMBOL(__register_key_type);* unregister_key_type - Unregister a type of key. * @ktype: The key type. * -* Unregister a key type and mark all the extant keys of this type as dead. -* Those keys of this type are then destroyed to get rid of their payloads and -* they and their links will be garbage collected as soon as possible. +* Unregister a key type. */ void unregister_key_type (struct key_type *ktype) {down_write (&key_types_sem);list_del_init (&ktype->link); -downgrade_write (&key_types_sem); -key_gc_keytype (ktype);pr_notice ("Key type %s unregistered\n" , ktype->name); -up_read (&key_types_sem); +up_write (&key_types_sem); }EXPORT_SYMBOL (unregister_key_type);
@@ -1324,7 +1320,6 @@ void __init key_init(void)/* add the special key types */ list_add_tail (&key_type_keyring.link, &key_types_list); -list_add_tail (&key_type_dead.link, &key_types_list);list_add_tail (&key_type_user.link, &key_types_list);list_add_tail (&key_type_logon.link, &key_types_list);
security/keys/keyring.c +0 -50
53 lines not on this page · raw message
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 12/13] KEYS: Remove key_type_dead
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
unregister_key_type()no longer needs to retype live keys as keys and restrictions pin the module while they reference it.Remove
key_type_deadand associated code from the keyring GC.Signed-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
Jarkko Sakkinen
maintainerPATCH v6 13/13 KEYS: key_garbage_collector(): process in chunks
In reply to Jarkko Sakkinenkey_garbage_collector() has a design that is not resistant enough for workqueue lockups. The duration scales up relative to the number of items in the serial tree, which causes a reoccuring theme of being guilty of causing workqueue lockups.
Resolve the problem by processing in chunks:
1. Declare a static variable key_gc_work, which owns the garbage collection in-flight state, and key_schedule_gc_work() for re-scheduling the work.
2. Define KEY_GC_CHUNK_SIZE, set to 64 keys, as the bound for the number of items scanned and destroyed.
3. Define KEY_GC_DESTROYING to mark resume to destruction without repeating the RCU grace period.
4. Define KEY_GC_REAP_REQUESTED for preserving full-pass requests across the continuations.
keygcbench results without the patch:
unused: min=413.359 avg=1817.240 max=3221.120 var=1970880.024 expired: min=0.002 avg=1360.124 max=2481.990 var=1055093.994 combined: min=0.002 avg=1542.970 max=3221.120 var=1471557.422
keygcbench results with the patch:
unused: min=0.005 avg=0.126 max=54.173 var=0.946 expired: min=0.002 avg=0.210 max=216.470 var=7.894 combined: min=0.002 avg=0.158 max=216.470 var=3.627
These results translate to:
- >99.9% drop in the combined variance.
- 3.0% increase in the total task time.
The value 64 for KEY_GC_CHUNK_SIZE was cherry-picked from the set {1, 2, ..., 1024} by running the benchmark for each chunk size three times.
At the far left variance is 97% lower but at the same time total time grows by 133%, when compared to the selected chunk size. The size was picked based on getting a reasonable variance with a minimal throughput decline.
--- security/keys/gc.c | 166 ++++++++++++++++++++++++++------------- security/keys/internal.h | 3 +- security/keys/key.c | 4 +- security/keys/keyring.c | 2 +- 4 files changed, 116 insertions(+), 59 deletions(-)
security/keys/gc.c +112 -54
@@ -11,10 +11,7 @@#include <keys/keyring-type.h> #include "internal.h" -/* -* Delay between key revocation/expiry in seconds -*/ -unsigned key_gc_delay =5 *60 ; +#define KEY_GC_CHUNK_SIZE 64/* * Reaper for unused keys.
@@ -22,18 +19,22 @@ unsigned key_gc_delay = 5 * 60;static void key_garbage_collector (struct work_struct *work);struct workqueue_struct *key_gc_wq__ro_after_init ; -DECLARE_WORK (key_gc_work, key_garbage_collector); -/** -* key_gc_flush - Drain the garbage collector RCU callbacks +static struct { +time64_t start;/* expiry range start */ +time64_t end;/* expiry range end */ +struct rb_node *cursor;/* serial tree position */ +u8 state;/* state flags */ +atomic_t seq; +struct work_struct work;/* work item */ +} key_gc_work = { + .work =__WORK_INITIALIZER (key_gc_work.work, key_garbage_collector), +}; + +/* +* Delay between key revocation/expiry in seconds */ -void key_gc_flush (void ) -{ -do { -rcu_barrier (); - }while (flush_work (&key_gc_work)); -} -EXPORT_SYMBOL_GPL (key_gc_flush); +unsigned int key_gc_delay =5 *60 ;/* * Reaper for links from keyrings to dead keys.
@@ -44,6 +45,42 @@ static DEFINE_TIMER(key_gc_timer, key_gc_timer_func);static time64_t key_gc_next_run =TIME64_MAX ;static unsigned long key_gc_flags;#define KEY_GC_KEY_EXPIRED 0/* A key expired and needs unlinking */ +#define KEY_GC_REAP_REQUESTED 1/* Another complete pass was requested */ + +/* +* Schedule a new GC pass or re-schedule an ongoing GC pass. +*/ +void key_schedule_gc_work (bool expired) +{ +unsigned long flags =BIT (KEY_GC_REAP_REQUESTED ); + +if (expired) + flags |=BIT (KEY_GC_KEY_EXPIRED ); + +/* Publish all request flags together, after the caller's updates. */ +set_mask_bits (&key_gc_flags,0 , flags); +queue_work (key_gc_wq, &key_gc_work.work); +} + +/** +* key_gc_flush - Drain the garbage collector RCU callbacks +*/ +void key_gc_flush (void ) +{ +int seq; + +do { +while (flush_work (&key_gc_work.work) || +work_pending (&key_gc_work.work)) +cpu_relax (); + seq =atomic_read_acquire (&key_gc_work.seq); +rcu_barrier (); + }while (flush_work (&key_gc_work.work) || +work_pending (&key_gc_work.work) || +atomic_read_acquire (&key_gc_work.seq) != seq); +} +EXPORT_SYMBOL_GPL (key_gc_flush); +/* * Schedule a garbage collection run. * - time precision isn't particularly important
@@ -57,7 +94,8 @@ void key_schedule_gc(time64_t gc_at)if (gc_at <= now) {kdebug ("IMMEDIATE" ); -queue_work (key_gc_wq, &key_gc_work); +/* Catch expirations that became due during the scan. */ +key_schedule_gc_work (true); }else if (gc_at < key_gc_next_run) {kdebug ("DEFERRED" ); key_gc_next_run = gc_at;
@@ -79,15 +117,6 @@ void key_set_expiry(struct key *key, time64_t expiry) } } -/* -* Schedule a dead links collection run. -*/ -void key_schedule_gc_links (void ) -{ -set_bit (KEY_GC_KEY_EXPIRED , &key_gc_flags); -queue_work (key_gc_wq, &key_gc_work); -} -/* * Some key's cleanup time was met after it expired, so we need to get the * reaper to go through a cycle finding expired keys.
@@ -96,7 +125,7 @@ static void key_gc_timer_func(struct timer_list *unused) {kenter ("" ); key_gc_next_run =TIME64_MAX ; -key_schedule_gc_links (); +key_schedule_gc_work (true); }/*
@@ -104,7 +133,9 @@ static void key_gc_timer_func(struct timer_list *unused)*/ static noinline void key_gc_unused_keys(struct list_head *keys) { -while (!list_empty (keys)) { +unsigned int chunk =KEY_GC_CHUNK_SIZE ; + +while (!list_empty (keys) && chunk--) {struct key *key = list_entry(keys->next, struct key, graveyard_link);struct module *owner = key->type->owner;
@@ -157,35 +188,46 @@ static noinline void key_gc_unused_keys(struct list_head *keys)static void key_garbage_collector (struct work_struct *work) {static LIST_HEAD (graveyard); -u8 gc_state =0 ; +typeof (key_gc_work) *gc = &key_gc_work;#define KEY_GC_REAP_AGAIN 0x01/* - Need another cycle */ #define KEY_GC_REAPING_LINKS 0x02/* - We need to reap links */ +#define KEY_GC_DESTROYING 0x04/* - We need to destroy keys */ -struct rb_node *cursor; +unsigned int chunk =KEY_GC_CHUNK_SIZE ; +unsigned long flags;struct key *key; -time64_t new_timer, limit, expiry; +time64_t expiry; -kenter ("[%lx]" , key_gc_flags); +kenter ("[%lx,%x]" , key_gc_flags, gc->state); - limit =ktime_get_real_seconds (); +if (gc->state &KEY_GC_DESTROYING ) + goto destroy_keys; +if (gc->cursor) { +spin_lock (&key_serial_lock); + goto continue_scanning; + } -if (test_and_clear_bit (KEY_GC_KEY_EXPIRED , &key_gc_flags)) - gc_state |=KEY_GC_REAPING_LINKS ; -kdebug ("new pass %x" , gc_state); + flags =xchg (&key_gc_flags,0 ); + gc->start =ktime_get_real_seconds (); + gc->state =0 ; +if (flags &BIT (KEY_GC_KEY_EXPIRED )) + gc->state |=KEY_GC_REAPING_LINKS ; +kdebug ("new pass %x" , gc->state); - new_timer =TIME64_MAX ; + gc->end =TIME64_MAX ;/* As only this function is permitted to remove things from the key * serial tree, if cursor is non-NULL then it will always point to a * valid node in the tree - even if lock got dropped. */ spin_lock (&key_serial_lock); - cursor =rb_first (&key_serial_tree); + gc->cursor =rb_first (&key_serial_tree); continue_scanning: -while (cursor) { - key = rb_entry(cursor, struct key, serial_node); - cursor =rb_next (cursor); +while (gc->cursor && chunk) { + key = rb_entry(gc->cursor, struct key, serial_node); + gc->cursor =rb_next (gc->cursor); + chunk--;if (!test_bit_acquire (KEY_FLAG_USER_ALIVE , &key->flags)) {/* Clobber key->user after final put seen. */
@@ -196,14 +238,14 @@ static void key_garbage_collector(struct work_struct *work)if (expiry !=TIME64_MAX ) {if (!(key->type->flags &KEY_TYPE_INSTANT_REAP )) expiry += key_gc_delay; -if (expiry > limit && expiry < new_timer) { +if (expiry > gc->start && expiry < gc->end) {kdebug ("will expire %x in %lld" , -key_serial (key), key->expiry - limit); - new_timer = key->expiry; +key_serial (key), expiry - gc->start); + gc->end = expiry; } } -if ((gc_state &KEY_GC_REAPING_LINKS ) && +if ((gc->state &KEY_GC_REAPING_LINKS ) && key->type == &key_type_keyring) goto found_keyring;
@@ -215,7 +257,11 @@ static void key_garbage_collector(struct work_struct *work)spin_unlock (&key_serial_lock); maybe_resched: -if (cursor) { +if (gc->cursor) { +if (!chunk) { +queue_work (key_gc_wq, &key_gc_work.work); + goto out; + }cond_resched ();spin_lock (&key_serial_lock); goto continue_scanning;
@@ -227,10 +273,8 @@ static void key_garbage_collector(struct work_struct *work)*/ kdebug ("pass complete" ); -if (new_timer !=TIME64_MAX ) { - new_timer += key_gc_delay; -key_schedule_gc (new_timer); - } +if (gc->end !=TIME64_MAX ) +key_schedule_gc (gc->end);if (!list_empty (&graveyard)) {/* Make sure that all pending keyring payload destructions are
@@ -240,13 +284,27 @@ static void key_garbage_collector(struct work_struct *work)*/ kdebug ("gc sync" );synchronize_rcu (); + } + + gc->state |=KEY_GC_DESTROYING ; + +destroy_keys: +if (!list_empty (&graveyard)) {kdebug ("gc keys" );key_gc_unused_keys (&graveyard); +if (!list_empty (&graveyard)) { +queue_work (key_gc_wq, &key_gc_work.work); + goto out; + } } - -if (gc_state &KEY_GC_REAP_AGAIN ) -queue_work (key_gc_wq, &key_gc_work); -kleave (" [end %x]" , gc_state); + gc->state &= ~KEY_GC_DESTROYING ; + +if ((gc->state &KEY_GC_REAP_AGAIN ) || +test_bit (KEY_GC_REAP_REQUESTED , &key_gc_flags)) +queue_work (key_gc_wq, &key_gc_work.work); +out: +atomic_inc_return (&gc->seq); +kleave (" [end %x]" , gc->state);return ;/* We found an unreferenced key - once we've removed it from the tree,
@@ -258,7 +316,7 @@ static void key_garbage_collector(struct work_struct *work)spin_unlock (&key_serial_lock);list_add_tail (&key->graveyard_link, &graveyard); - gc_state |=KEY_GC_REAP_AGAIN ; + gc->state |=KEY_GC_REAP_AGAIN ; goto maybe_resched;/* We found a keyring and we need to check the payload for links to
@@ -268,6 +326,6 @@ static void key_garbage_collector(struct work_struct *work)*/ found_keyring:spin_unlock (&key_serial_lock); -keyring_gc (key, limit); +keyring_gc (key, gc->start); goto maybe_resched; }
security/keys/internal.h +1 -2
@@ -161,13 +161,12 @@ extern bool lookup_user_key_possessed(const struct key *key,extern long join_session_keyring (const char *name);extern void key_change_session_keyring (struct callback_head *twork); -extern struct work_struct key_gc_work;extern unsigned key_gc_delay;extern struct workqueue_struct *key_gc_wq;extern void keyring_gc (struct key *keyring,time64_t limit);void key_set_expiry (struct key *key,time64_t expiry);extern void key_schedule_gc (time64_t gc_at); -extern void key_schedule_gc_links (void ); +void key_schedule_gc_work (bool expired); extern int key_task_permission(const key_ref_t key_ref, const struct cred *cred,
security/keys/key.c +2 -2
@@ -693,7 +693,7 @@ void key_put(struct key *key) }/* Mark key as safe for GC after key->user done. */ clear_bit_unlock (KEY_FLAG_USER_ALIVE , &key->flags); -queue_work (key_gc_wq, &key_gc_work); +key_schedule_gc_work (false); } } }
@@ -1214,7 +1214,7 @@ void key_invalidate(struct key *key)down_write_nested (&key->sem,1 );if (!test_and_set_bit (KEY_FLAG_INVALIDATED , &key->flags)) {notify_key (key,NOTIFY_KEY_INVALIDATED ,0 ); -key_schedule_gc_links (); +key_schedule_gc_work (true); }up_write (&key->sem); }
security/keys/keyring.c +1 -1
@@ -266,7 +266,7 @@ void key_remove_domain(struct key_tag *domain_tag) { domain_tag->removed = true;if (!key_put_tag (domain_tag)) -key_schedule_gc_links (); +key_schedule_gc_work (true); }/*
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH v6 13/13] KEYS: key_garbage_collector(): process in chunks
Sashiko has reviewed this patch and found no issues.
Quoted 18 lines
key_garbage_collector()has a design that is not resistant enough for workqueue lockups. The duration scales up relative to the number of items in the serial tree, which causes a reoccuring theme of being guilty of causing workqueue lockups.Resolve the problem by processing in chunks:
1. Declare a static variable
key_gc_work, which owns the garbage collection in-flight state, andkey_schedule_gc_work()for re-scheduling the work.
2. DefineKEY_GC_CHUNK_SIZE, set to 64 keys, as the bound for the number of items scanned and destroyed.
3. DefineKEY_GC_DESTROYINGto mark resume to destruction without repeating the RCU grace period.
4. DefineKEY_GC_REAP_REQUESTEDfor preserving full-pass requests across the continuations.
[ ... ]
decline.
Quoted 3 lines
Fixes 0c061b5707ab ("KEYS: Correctly destroy key payloads when their keytype is removed")Link https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd-test.git/tree/package/keygcbenchSigned-off-by Jarkko Sakkinen <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=13
Jarkko Sakkinen
maintainerQuoted 1 line · Jarkko Sakkinen
<SNIP>
All Sashiko responses show "no issues".
I assumed different because in the past I've received responses only when it finds something; so I checked them all through.
Br, Jarkko
Jarkko Sakkinen
maintainerQuoted 7 lines · Jarkko Sakkinen
1. Replace
key_type_deadretyping with module reference pinning so live keys and restrictions keep their backingkey_typemodule loaded untilkey_gc_unused_keys()orkeyring_destroy()completes.
2. Process serial-tree scans and graveyard destruction in fixed 64-key chunks to a bound workqueue execution latency without hurting overall throughput for a significant amount.
Quoted 6 lines
The first part has a user-space visible effect: rmmod returns
-EBUSYwhile keys or keyring restrictions still pin the backing module.Internal key caches or transport state bottlenecks are addressed by either clearing their private caches on last-client teardown or splitting key types into dedicated provider modules.
This passes [email protected] and Sashiko other than the remark about inline comment.
I'll update the inline comment, and make the commits available at -next.
I'll leave S390 fixes out as they are out-of-band. They can be picked from this patch set; or I can later on send a separate patch set.
Br, Jarkko
Jarkko Sakkinen
maintainerQuoted 18 lines · Jarkko Sakkinen
Quoted 7 lines · Jarkko Sakkinen
1. Replace
key_type_deadretyping with module reference pinning so live keys and restrictions keep their backingkey_typemodule loaded untilkey_gc_unused_keys()orkeyring_destroy()completes.
2. Process serial-tree scans and graveyard destruction in fixed 64-key chunks to a bound workqueue execution latency without hurting overall throughput for a significant amount.Quoted 6 lines
The first part has a user-space visible effect: rmmod returns
-EBUSYwhile keys or keyring restrictions still pin the backing module.Internal key caches or transport state bottlenecks are addressed by either clearing their private caches on last-client teardown or splitting key types into dedicated provider modules.
This passes [email protected] and Sashiko other than the remark about inline comment.
Quoted 6 lines
I'll update the inline comment, and make the commits available at -next.
I'll leave S390 fixes out as they are out-of-band. They can be picked from this patch set; or I can later on send a separate patch set.
Done: https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/log/?h=for-next-keys
Br, Jarkko