KEYS: Fix an RCU warning in the reading of user keys
Subsystems (2)
David Howells
maintainerPATCH 1/7 KEYS: Fix an RCU warning in the reading of user keys
Fix an RCU warning in the reading of user keys:
===================================================
[ INFO: suspicious rcu_dereference_check() usage. ]
---------------------------------------------------security/keys/user_defined.c:202 invoked rcu_dereference_check() without protection!
other info that might help us debug this:
rcu_scheduler_active = 1, debug_locks = 0
1 lock held by keyctl/3637:
#0: (&key->sem){+++++.}, at: [<ffffffff811a80ae>] keyctl_read_key+0x9c/0xcf
stack backtrace: Pid: 3637, comm: keyctl Not tainted 2.6.34-rc5-cachefs #18 Call Trace: [<ffffffff81051f6c>] lockdep_rcu_dereference+0xaa/0xb2 [<ffffffff811aa55f>] user_read+0x47/0x91 [<ffffffff811a80be>] keyctl_read_key+0xac/0xcf [<ffffffff811a8a06>] sys_keyctl+0x75/0xb7 [<ffffffff81001eeb>] system_call_fastpath+0x16/0x1b
---
security/keys/user_defined.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)
security/keys/user_defined.c +2 -1
@@ -199,7 +199,8 @@ long user_read(const struct key *key, char __user *buffer, size_t buflen)struct user_key_payload *upayload;long ret; - upayload =rcu_dereference (key->payload.data); + upayload =rcu_dereference_protected ( + key->payload.data,rwsem_is_locked (&((struct key *)key)->sem)); ret = upayload->datalen;/* we can return the data as is */
David Howells
maintainerPATCH 2/7 KEYS: find_keyring_by_name() can gain access to a freed keyring
From: Toshiyuki Okajima <[email protected]>
find_keyring_by_name() can gain access to a keyring that has had its reference count reduced to zero, and is thus ready to be freed. This then allows the dead keyring to be brought back into use whilst it is being destroyed.
The following timeline illustrates the process:
|(cleaner) (user)
|
| free_user(user) sys_keyctl()
| | |
| key_put(user->session_keyring) keyctl_get_keyring_ID()
| || //=> keyring->usage = 0 |
| |schedule_work(&key_cleanup_task) lookup_user_key()
| || |
| kmem_cache_free(,user) |
| . |[KEY_SPEC_USER_KEYRING]
| . install_user_keyrings()
| . ||
| key_cleanup() [<= worker_thread()] ||
| | ||
| [spin_lock(&key_serial_lock)] |[mutex_lock(&key_user_keyr..mutex)]
| | ||
| atomic_read() == 0 ||
| |{ rb_ease(&key->serial_node,) } ||
| | ||
| [spin_unlock(&key_serial_lock)] |find_keyring_by_name()
| | |||
| keyring_destroy(keyring) ||[read_lock(&keyring_name_lock)]
| || |||
| |[write_lock(&keyring_name_lock)] ||atomic_inc(&keyring->usage)
| |. ||| *** GET freeing keyring ***
| |. ||[read_unlock(&keyring_name_lock)]
| || ||
| |list_del() |[mutex_unlock(&key_user_k..mutex)]
| || |
| |[write_unlock(&keyring_name_lock)] ** INVALID keyring is returned **
| | .
| kmem_cache_free(,keyring) .
| .
| atomic_dec(&keyring->usage)v *** DESTROYED ***
TIME
If CONFIG_SLUB_DEBUG=y then we may see the following message generated:
============================================================================= BUG key_jar: Poison overwritten ----------------------------------------------------------------------------- INFO: 0xffff880197a7e200-0xffff880197a7e200. First byte 0x6a instead of 0x6b INFO: Allocated in key_alloc+0x10b/0x35f age=25 cpu=1 pid=5086 INFO: Freed in key_cleanup+0xd0/0xd5 age=12 cpu=1 pid=10 INFO: Slab 0xffffea000592cb90 objects=16 used=2 fp=0xffff880197a7e200 flags=0x200000000000c3 INFO: Object 0xffff880197a7e200 @offset=512 fp=0xffff880197a7e300 Bytes b4 0xffff880197a7e1f0: 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a 5a ZZZZZZZZZZZZZZZZ Object 0xffff880197a7e200: 6a 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b jkkkkkkkkkkkkkkk
Alternatively, we may see a system panic happen, such as:
BUG: unable to handle kernel NULL pointer dereference at 0000000000000001 IP: [<ffffffff810e61a3>] kmem_cache_alloc+0x5b/0xe9 PGD 6b2b4067 PUD 6a80d067 PMD 0 Oops: 0000 [#1] SMP last sysfs file: /sys/kernel/kexec_crash_loaded CPU 1 ... Pid: 31245, comm: su Not tainted 2.6.34-rc5-nofixed-nodebug #2 D2089/PRIMERGY RIP: 0010:[<ffffffff810e61a3>] [<ffffffff810e61a3>] kmem_cache_alloc+0x5b/0xe9 RSP: 0018:ffff88006af3bd98 EFLAGS: 00010002 RAX: 0000000000000000 RBX: 0000000000000001 RCX: ffff88007d19900b RDX: 0000000100000000 RSI: 00000000000080d0 RDI: ffffffff81828430 RBP: ffffffff81828430 R08: ffff88000a293750 R09: 0000000000000000 R10: 0000000000000001 R11: 0000000000100000 R12: 00000000000080d0 R13: 00000000000080d0 R14: 0000000000000296 R15: ffffffff810f20ce FS: 00007f97116bc700(0000) GS:ffff88000a280000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000000000000001 CR3: 000000006a91c000 CR4: 00000000000006e0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400 Process su (pid: 31245, threadinfo ffff88006af3a000, task ffff8800374414c0) Stack: 0000000512e0958e 0000000000008000 ffff880037f8d180 0000000000000001 0000000000000000 0000000000008001 ffff88007d199000 ffffffff810f20ce 0000000000008000 ffff88006af3be48 0000000000000024 ffffffff810face3 Call Trace: [<ffffffff810f20ce>] ? get_empty_filp+0x70/0x12f [<ffffffff810face3>] ? do_filp_open+0x145/0x590 [<ffffffff810ce208>] ? tlb_finish_mmu+0x2a/0x33 [<ffffffff810ce43c>] ? unmap_region+0xd3/0xe2 [<ffffffff810e4393>] ? virt_to_head_page+0x9/0x2d [<ffffffff81103916>] ? alloc_fd+0x69/0x10e [<ffffffff810ef4ed>] ? do_sys_open+0x56/0xfc [<ffffffff81008a02>] ? system_call_fastpath+0x16/0x1b Code: 0f 1f 44 00 00 49 89 c6 fa 66 0f 1f 44 00 00 65 4c 8b 04 25 60 e8 00 00 48 8b 45 00 49 01 c0 49 8b 18 48 85 db 74 0d 48 63 45 18 <48> 8b 04 03 49 89 00 eb 14 4c 89 f9 83 ca ff 44 89 e6 48 89 ef RIP [<ffffffff810e61a3>] kmem_cache_alloc+0x5b/0xe9
This problem is that find_keyring_by_name does not confirm that the keyring is valid before accepting it.
Skipping keyrings that have been reduced to a zero count seems the way to go. To this end, use atomic_inc_not_zero() to increment the usage count and skip the candidate keyring if that returns false.
The following script _may_ cause the bug to happen, but there's no guarantee as the window of opportunity is small:
#!/bin/sh
LOOP=100000
USER=dummy_user
/bin/su -c "exit;" $USER || { /usr/sbin/adduser -m $USER; add=1; }
for ((i=0; i<LOOP; i++))
do
/bin/su -c "echo '$i' > /dev/null" $USER
done
(( add == 1 )) && /usr/sbin/userdel -r $USER
exitNote that the nominated user must not be in use.
An alternative way of testing this may be:
for ((i=0; i<100000; i++)) do keyctl session foo /bin/true || break done >&/dev/null
as that uses a keyring named "foo" rather than relying on the user and user-session named keyrings.
---
security/keys/keyring.c | 18 +++++++++--------- 1 files changed, 9 insertions(+), 9 deletions(-)
security/keys/keyring.c +9 -9
@@ -526,9 +526,8 @@ struct key *find_keyring_by_name(const char *name, bool skip_perm_check)struct key *keyring;int bucket; - keyring =ERR_PTR (-EINVAL );if (!name) - goto error; +return ERR_PTR (-EINVAL ); bucket =keyring_hash (name);
@@ -555,17 +554,18 @@ struct key *find_keyring_by_name(const char *name, bool skip_perm_check) KEY_SEARCH) < 0)continue ; -/* we've got a match */ -atomic_inc (&keyring->usage); -read_unlock (&keyring_name_lock); - goto error; +/* we've got a match but we might end up racing with +* key_cleanup() if the keyring is currently 'dead' +* (ie. it has a zero usage count) */ +if (!atomic_inc_not_zero (&keyring->usage)) +continue ; + goto out; } } -read_unlock (&keyring_name_lock); keyring =ERR_PTR (-ENOKEY ); - - error: +out: +read_unlock (&keyring_name_lock);return keyring; }/* end find_keyring_by_name() */
Re: [PATCH 2/7] KEYS: find_keyring_by_name() can gain access to a freed keyring
Quoted 3 lines · David Howells
Reported-by Toshiyuki Okajima <[email protected]>Signed-off-by David Howells <[email protected]>Tested-by Toshiyuki Okajima <[email protected]>
(looks good, fwiw)
David Howells
maintainerPATCH 3/7 KEYS: Use RCU dereference wrappers in keyring key type code
In reply to David HowellsThe keyring key type code should use RCU dereference wrappers, even when it holds the keyring's key semaphore.
---
security/keys/keyring.c | 23 +++++++++++++---------- 1 files changed, 13 insertions(+), 10 deletions(-)
security/keys/keyring.c +13 -10
@@ -20,6 +20,11 @@#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))) +/* * when plumbing the depths of the key tree, this sets a hard limit set on how * deep we're willing to go
@@ -201,8 +206,7 @@ static long keyring_read(const struct key *keyring,int loop, ret; ret =0 ; - klist = keyring->payload.subscriptions; - + klist =rcu_dereference_locked_keyring (keyring);if (klist) {/* calculate how much data we could return */ qty = klist->nkeys *sizeof (key_serial_t);
@@ -720,8 +724,7 @@ int __key_link(struct key *keyring, struct key *key) }/* see if there's a matching key we can displace */ - klist = keyring->payload.subscriptions; - + klist =rcu_dereference_locked_keyring (keyring);if (klist && klist->nkeys >0 ) {struct key_type *type = key->type;
@@ -765,8 +768,6 @@ int __key_link(struct key *keyring, struct key *key)if (ret <0 ) goto error2; - klist = keyring->payload.subscriptions; -if (klist && klist->nkeys < klist->maxkeys) {/* there's sufficient slack space to add directly */ atomic_inc (&key->usage);
@@ -867,7 +868,7 @@ int key_unlink(struct key *keyring, struct key *key)down_write (&keyring->sem); - klist = keyring->payload.subscriptions; + klist =rcu_dereference_locked_keyring (keyring);if (klist) {/* search the keyring for the key */ for (loop =0 ; loop < klist->nkeys; loop++)
@@ -958,7 +959,7 @@ int keyring_clear(struct key *keyring)/* detach the pointer block with the locks held */ down_write (&keyring->sem); - klist = keyring->payload.subscriptions; + klist =rcu_dereference_locked_keyring (keyring);if (klist) {/* adjust the quota */ key_payload_reserve(keyring,
@@ -990,7 +991,9 @@ EXPORT_SYMBOL(keyring_clear);*/ static void keyring_revoke (struct key *keyring) { -struct keyring_list *klist = keyring->payload.subscriptions; +struct keyring_list *klist; + + klist =rcu_dereference_locked_keyring (keyring);/* adjust the quota */ key_payload_reserve (keyring,0 );
@@ -1024,7 +1027,7 @@ void keyring_gc(struct key *keyring, time_t limit)down_write (&keyring->sem); - klist = keyring->payload.subscriptions; + klist =rcu_dereference_locked_keyring (keyring);if (!klist) goto no_klist;
Re: [PATCH 3/7] KEYS: Use RCU dereference wrappers in keyring key type code
Quoted 5 lines · David Howells
The keyring key type code should use RCU dereference wrappers, even when it holds the keyring's key semaphore.
Reported-by Vegard Nossum <[email protected]>Signed-off-by David Howells <[email protected]>
<shrug> does this mean that the
klist = rcu_dereference_check(keyring->payload.subscriptions, lockdep_is_held(&key_serial_lock));
in security/keys/gc.c:key_gc_keyring() should become a rcu_dereference_protected() to avoid the rcu_dereference_raw() and for consistency?
Quoted 22 lines
---
security/keys/keyring.c | 23 +++++++++++++---------- 1 files changed, 13 insertions(+), 10 deletions(-)security/keys/keyring.c +5
-0@@ -20,6 +20,11 @@#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))) +/* * when plumbing the depths of the key tree, this sets a hard limit set on how * deep we're willing to go
security/keys/keyring.c static long keyring_read(const struct key *keyring, · line 209
Quoted 6 lines
security/keys/keyring.c +1
-2@@ -201,8 +206,7 @@ static long keyring_read(const struct key *keyring,int loop, ret; ret =0 ; - klist = keyring->payload.subscriptions; - + klist =rcu_dereference_locked_keyring (keyring);
Weird, this was a straight rcu_dereference in my tree (which would still deserve a switch for the same reason as patch 1 of course)
Quoted 14 lines
security/keys/keyring.c +1
-2if (klist) {/* calculate how much data we could return */ qty = klist->nkeys *sizeof (key_serial_t);@@ -720,8 +724,7 @@ int __key_link(struct key *keyring, struct key *key) }/* see if there's a matching key we can displace */ - klist = keyring->payload.subscriptions; - + klist =rcu_dereference_locked_keyring (keyring);if (klist && klist->nkeys >0 ) {struct key_type *type = key->type;
security/keys/keyring.c int __key_link(struct key *keyring, struct key *key) · line 769
Quoted 5 lines
security/keys/keyring.c +0
-2@@ -765,8 +768,6 @@ int __key_link(struct key *keyring, struct key *key)if (ret <0 ) goto error2; - klist = keyring->payload.subscriptions; -
huh, yeah, seems to have been there and unneeded since at least 2007.
-serge
David Howells
maintainerRe: [PATCH 3/7] KEYS: Use RCU dereference wrappers in keyring key type code
Quoted 6 lines · Serge E. Hallyn
<shrug> does this mean that the
klist = rcu_dereference_check(keyring->payload.subscriptions, lockdep_is_held(&key_serial_lock));in security/keys/gc.c:key_gc_keyring() should become a
rcu_dereference_protected()to avoid thercu_dereference_raw()and for consistency?
Well spotted. That's incorrect modification by commit e7b0a61b7929632d36cf052d9e2820ef0a9c1bfe.
key_serial_lock is not a guarantor of the current keyring subscriptions not changing as we read it. We need to hold either the RCU read lock (so that the what the pointer currently points to isn't trashed) or the keyring semaphore (so that the keyring isn't changed under us).
The real error is not holding the RCU read lock (I'd assumed that the fact it was holding a spinlock implied this - which I now know to be wrong).
David
David Howells
maintainerPATCH 4/7 KEYS: call_sbin_request_key() must write lock keyrings before modifying them
In reply to David Howellscall_sbin_request_key() creates a keyring and then attempts to insert a link to the authorisation key into that keyring, but does so without holding a write lock on the keyring semaphore.
It will normally get away with this because it hasn't told anyone that the keyring exists yet. The new keyring, however, has had its serial number published, which means it can be accessed directly by that handle.
This was found by a previous patch that adds RCU lockdep checks to the code that reads the keyring payload pointer, which includes a check that the keyring semaphore is actually locked.
Without this patch, the following command:
keyctl request2 user b a @s
will provoke the following lockdep warning is displayed in dmesg:
===================================================
[ INFO: suspicious rcu_dereference_check() usage. ]
---------------------------------------------------
security/keys/keyring.c:727 invoked rcu_dereference_check() without protection!
other info that might help us debug this:
rcu_scheduler_active = 1, debug_locks = 0
2 locks held by keyctl/2076:
#0: (key_types_sem){.+.+.+}, at: [<ffffffff811a5b29>] key_type_lookup+0x1c/0x71
#1: (keyring_serialise_link_sem){+.+.+.}, at: [<ffffffff811a6d1e>] __key_link+0x4d/0x3c5
stack backtrace:
Pid: 2076, comm: keyctl Not tainted 2.6.34-rc6-cachefs #54
Call Trace:
[<ffffffff81051fdc>] lockdep_rcu_dereference+0xaa/0xb2
[<ffffffff811a6d1e>] ? __key_link+0x4d/0x3c5
[<ffffffff811a6e6f>] __key_link+0x19e/0x3c5
[<ffffffff811a5952>] ? __key_instantiate_and_link+0xb1/0xdc
[<ffffffff811a59bf>] ? key_instantiate_and_link+0x42/0x5f
[<ffffffff811aa0dc>] call_sbin_request_key+0xe7/0x33b
[<ffffffff8139376a>] ? mutex_unlock+0x9/0xb
[<ffffffff811a5952>] ? __key_instantiate_and_link+0xb1/0xdc
[<ffffffff811a59bf>] ? key_instantiate_and_link+0x42/0x5f
[<ffffffff811aa6fa>] ? request_key_auth_new+0x1c2/0x23c
[<ffffffff810aaf15>] ? cache_alloc_debugcheck_after+0x108/0x173
[<ffffffff811a9d00>] ? request_key_and_link+0x146/0x300
[<ffffffff810ac568>] ? kmem_cache_alloc+0xe1/0x118
[<ffffffff811a9e45>] request_key_and_link+0x28b/0x300
[<ffffffff811a89ac>] sys_request_key+0xf7/0x14a
[<ffffffff81052c0b>] ? trace_hardirqs_on_caller+0x10c/0x130
[<ffffffff81394fb9>] ? trace_hardirqs_on_thunk+0x3a/0x3f
[<ffffffff81001eeb>] system_call_fastpath+0x16/0x1b---
security/keys/request_key.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
security/keys/request_key.c +1 -1
@@ -94,7 +94,7 @@ static int call_sbin_request_key(struct key_construction *cons, }/* attach the auth key to the session keyring */ - ret =__key_link (keyring, authkey); + ret =key_link (keyring, authkey);if (ret <0 ) goto error_link;
David Howells
maintainerPATCH 5/7 KEYS: keyring_serialise_link_sem is only needed for keyring->keyring links
In reply to David Howellskeyring_serialise_link_sem is only needed for keyring->keyring links as it's used to prevent cycle detection from being avoided by parallel keyring additions.
---
security/keys/keyring.c | 16 +++++++++------- 1 files changed, 9 insertions(+), 7 deletions(-)
security/keys/keyring.c +9 -7
@@ -711,13 +711,14 @@ int __key_link(struct key *keyring, struct key *key)if (keyring->type != &key_type_keyring) goto error; -/* serialise link/link calls to prevent parallel calls causing a -* cycle when applied to two keyring in opposite orders */ -down_write (&keyring_serialise_link_sem); - -/* check that we aren't going to create a cycle adding one keyring to -* another */ +/* do some special keyring->keyring link checks */ if (key->type == &key_type_keyring) { +/* serialise link/link calls to prevent parallel calls causing +* a cycle when applied to two keyring in opposite orders */ +down_write (&keyring_serialise_link_sem); + +/* check that we aren't going to create a cycle adding one +* keyring to another */ ret =keyring_detect_cycle (keyring, key);if (ret <0 ) goto error2;
@@ -817,7 +818,8 @@ int __key_link(struct key *keyring, struct key *key) done: ret =0 ; error2: -up_write (&keyring_serialise_link_sem); +if (key->type == &key_type_keyring) +up_write (&keyring_serialise_link_sem); error:return ret;
David Howells
maintainerPATCH 6/7 KEYS: Better handling of errors from construct_alloc_key()
In reply to David HowellsErrors from construct_alloc_key() shouldn't just be ignored in the way they are by construct_key_and_link(). The only error that can be ignored so is EINPROGRESS as that is used to indicate that we've found a key and don't need to construct one.
We don't, however, handle ENOMEM, EDQUOT or EACCES to indicate allocation failures of one sort or another.
---
security/keys/request_key.c | 24 ++++++++++++++++++++++-- 1 files changed, 22 insertions(+), 2 deletions(-)
security/keys/request_key.c +22 -2
@@ -302,6 +302,7 @@ static int construct_alloc_key(struct key_type *type,const struct cred *cred =current_cred ();struct key *key;key_ref_t key_ref; +int ret;kenter ("%s,%s,,," , type->name, description);
@@ -337,14 +338,23 @@ static int construct_alloc_key(struct key_type *type,kleave (" = 0 [%d]" ,key_serial (key));return 0 ; +/* the key is now present - we tell the caller that we found it by +* returning -EINPROGRESS */ key_already_present:mutex_unlock (&key_construction_mutex); + ret =0 ;if (dest_keyring) { -__key_link (dest_keyring,key_ref_to_ptr (key_ref)); + ret =__key_link (dest_keyring,key_ref_to_ptr (key_ref));up_write (&dest_keyring->sem); }mutex_unlock (&user->cons_lock);key_put (key); +if (ret <0 ) { +key_ref_put (key_ref); + *_key =NULL ; +kleave (" = %d [link]" , ret); +return ret; + } *_key = key =key_ref_to_ptr (key_ref);kleave (" = -EINPROGRESS [%d]" ,key_serial (key));return -EINPROGRESS ;
@@ -390,6 +400,10 @@ static struct key *construct_key_and_link(struct key_type *type,kdebug ("cons failed" ); goto construction_failed; } + }else if (ret == -EINPROGRESS ) { + ret =0 ; + }else { + key =ERR_PTR (ret); }key_put (dest_keyring);
@@ -422,6 +436,7 @@ struct key *request_key_and_link(struct key_type *type,const struct cred *cred =current_cred ();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,
@@ -435,8 +450,13 @@ struct key *request_key_and_link(struct key_type *type, key =key_ref_to_ptr (key_ref);if (dest_keyring) {construct_get_dest_keyring (&dest_keyring); -key_link (dest_keyring, key); + ret =key_link (dest_keyring, key);key_put (dest_keyring); +if (ret <0 ) { +key_put (key); + key =ERR_PTR (ret); + goto error; + } } }else if (PTR_ERR (key_ref) != -EAGAIN ) { key =ERR_CAST (key_ref);
David Howells
maintainerPATCH 7/7 KEYS: Do preallocation for __key_link()
In reply to David HowellsDo preallocation for __key_link() so that the various callers in request_key.c can deal with any errors from this source before attempting to construct a key. This allows them to assume that the actual linkage step is guaranteed to be successful.
---
security/keys/internal.h | 11 ++ security/keys/key.c | 45 +++++--- security/keys/keyring.c | 242 ++++++++++++++++++++++++++----------------- security/keys/request_key.c | 47 ++++++-- 4 files changed, 215 insertions(+), 130 deletions(-)
security/keys/internal.h +10 -1
@@ -87,7 +87,16 @@ extern wait_queue_head_t request_key_conswq;extern struct key_type *key_type_lookup (const char *type);extern void key_type_put (struct key_type *ktype); -extern int __key_link (struct key *keyring,struct key *key); +extern int __key_link_begin (struct key *keyring, +const struct key_type *type, +const char *description, +struct keyring_list **_prealloc); +extern int __key_link_check_live_key (struct key *keyring,struct key *key); +extern void __key_link (struct key *keyring,struct key *key, +struct keyring_list **_prealloc); +extern void __key_link_end (struct key *keyring, +struct key_type *type, +struct keyring_list *prealloc); extern key_ref_t __keyring_search_one(key_ref_t keyring_ref, const struct key_type *type,
security/keys/key.c +29 -16
128 lines not on this page · raw message
security/keys/keyring.c +145 -97
330 lines not on this page · raw message
security/keys/request_key.c +31 -16
89 lines not on this page · raw message
Quoted 23 lines · David Howells
Fix an RCU warning in the reading of user keys:
===================================================
[ INFO: suspiciousrcu_dereference_check()usage. ]
---------------------------------------------------security/keys/user_defined.c:202invokedrcu_dereference_check()without protection!other info that might help us debug this:
rcu_scheduler_active= 1,debug_locks= 0
1 lock held by keyctl/3637:
#0: (&key->sem){+++++.}, at: [<ffffffff811a80ae>]keyctl_read_key+0x9c/0xcfstack backtrace: Pid: 3637, comm: keyctl Not tainted 2.6.34-rc5-cachefs #18 Call Trace: [<ffffffff81051f6c>] lockdep_rcu_dereference+0xaa/0xb2 [<ffffffff811aa55f>] user_read+0x47/0x91 [<ffffffff811a80be>] keyctl_read_key+0xac/0xcf [<ffffffff811a8a06>] sys_keyctl+0x75/0xb7 [<ffffffff81001eeb>] system_call_fastpath+0x16/0x1b
Quoted 1 line
Signed-off-by David Howells <[email protected]>
heck it also serves to document it a bit, as looking at the fn itself it's not clear that it is called under key->sem.
Quoted 24 lines
---
security/keys/user_defined.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)security/keys/user_defined.c +2
-2@@ -199,7 +199,8 @@ long user_read(const struct key *key, char __user *buffer, size_t buflen)struct user_key_payload *upayload;long ret; - upayload =rcu_dereference (key->payload.data); + upayload =rcu_dereference_protected ( + key->payload.data,rwsem_is_locked (&((struct key *)key)->sem)); ret = upayload->datalen;/* we can return the data as is */ --To unsubscribe from this list: send the line "unsubscribe linux-security-module" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
David Howells
maintainerQuoted 2 lines · Serge E. Hallyn
heck it also serves to document it a bit, as looking at the fn itself it's not clear that it is called under
key->sem.
Give or take the banner comment on user_read() where it states this explicitly:
/*
* read the key data
* - the key's semaphore is read-locked
*/
long user_read(const struct key *key, char __user *buffer, size_t buflen)
and Documentation/keys.txt where it also states this explicitly:
(*) long (*read)(const struct key *key, char __user *buffer, size_t buflen);
...
This method will be called with the key's semaphore read-locked. This will prevent the key's payload changing. It is not necessary to use RCU locking when accessing the key's payload. It is safe to sleep in this method, such as might happen when the userspace buffer is accessed.
:-)
David
David
James Morris
maintainerOkay... patches 1-4 have gone into -linus, along with 'KEYS: Fix RCU handling in key_gc_keyring()'
The should probably all be in -stable (see the most recent 'keys' patches in -linus).
Patches 5 & 6 are in:git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/security-testing-2.6#next
The final patch does not apply to my tree -- please rebase it.
- James
Signature · 2 lines
James Morris <[email protected]>
David Howells
maintainerQuoted 1 line · James Morris
The final patch does not apply to my tree -- please rebase it.
Your tree is not up to date with respect to Linus's: you're missing the three patches he pulled in yesterday.
David
James Morris
maintainerQuoted 6 lines · David Howells
Quoted 1 line · James Morris
The final patch does not apply to my tree -- please rebase it.
Your tree is not up to date with respect to Linus's: you're missing the three patches he pulled in yesterday.
Ok, I forgot to pull from Linus' tree before merging locally, looks fine now.
Signature · 2 lines
James Morris <[email protected]>