ceph: fix OOB read in decode_lockers() via missing bounds check
Subsystems (2)
PATCH 1/1 ceph: fix OOB read in decode_lockers() via missing bounds check
ceph_start_decoding() accepts struct_len=0 as valid:ceph_decode_need(p, end, 0, bad) always passes. When a malicious or compromised OSD sends a cls_lock_get_info_reply with struct_len=0, ceph_start_decoding() returns success with p == end, leaving zero bytes guaranteed for subsequent reads.
The immediately following bare ceph_decode_32(p) in decode_lockers() has no preceding bounds check. With p == end this is a 4-byte read past the validated buffer boundary. The garbage value is then passed to kzalloc_objs() as the locker count.
The sibling function decode_watchers() in osd_client.c already uses the safe variant ceph_decode_32_safe() after its own ceph_start_decoding() call. decode_lockers() is the only site using the bare variant, confirming an oversight.
Fix by replacing ceph_decode_32(p) with ceph_decode_32_safe(p, end, *num_lockers, err_inval), adding a new err_inval label that returns -EINVAL directly without attempting to free an uninitialized lockers pointer.
KASAN report (kernel 7.0.0-rc7, QEMU/x86_64, KASLR disabled):
==================================================================
BUG: KASAN: slab-out-of-bounds in ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc]
Read of size 4 at addr ffff88800a29b76e by task insmod/58
CPU: 0 UID: 0 PID: 58 Comm: insmod Tainted: G O 7.0.0-rc7-g9c2abf69da83-dirty #15 PREEMPT(lazy)
Tainted: [O]=OOT_MODULE
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0-debian-1.17.0-1 04/01/2014
Call Trace:
<TASK>
dump_stack_lvl+0x4d/0x70
print_report+0x170/0x4f3
kasan_report+0xda/0x110
ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc]
do_one_initcall+0x9a/0x3a0
do_init_module+0x27c/0x790
load_module+0x4a9a/0x6350
init_module_from_file+0x15c/0x180
idempotent_init_module+0x21f/0x750
__x64_sys_finit_module+0xba/0x120
do_syscall_64+0xe2/0x570
entry_SYSCALL_64_after_hwframe+0x77/0x7f
Allocated by task 58:
kasan_save_stack+0x30/0x50
kasan_save_track+0x14/0x30
__kasan_kmalloc+0x7f/0x90
ceph_oob3_init+0x4d/0xff0 [ceph_oob3_poc]
do_one_initcall+0x9a/0x3a0
do_init_module+0x27c/0x790
load_module+0x4a9a/0x6350
init_module_from_file+0x15c/0x180
idempotent_init_module+0x21f/0x750
__x64_sys_finit_module+0xba/0x120
do_syscall_64+0xe2/0x570
entry_SYSCALL_64_after_hwframe+0x77/0x7f
The buggy address belongs to the object at ffff88800a29a000
which belongs to the cache kmalloc-8k of size 8192
The buggy address is located 5998 bytes inside of
allocated 6000-byte region [ffff88800a29a000, ffff88800a29b770)
Memory state around the buggy address:
ffff88800a29b600: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
ffff88800a29b680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
>ffff88800a29b700: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 fc fc
^
ffff88800a29b780: fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc
==================================================================num_lockers=0xccccaaaa (OOB garbage from KASAN redzone)
Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment can trigger this against any kernel client that issues the lock.get_info class method (e.g. during RBD exclusive lock acquisition) without any further privileges beyond OSD session establishment.
--- net/ceph/cls_lock_client.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
net/ceph/cls_lock_client.c +3 -1
@@ -299,7 +299,7 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag,if (ret)return ret; - *num_lockers =ceph_decode_32 (p); +ceph_decode_32_safe (p, end, *num_lockers, err_inval); *lockers =kzalloc_objs (**lockers, *num_lockers,GFP_NOIO );if (!*lockers)return -ENOMEM ;
@@ -320,6 +320,8 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, *tag = s;return 0 ; +err_inval: +return -EINVAL ; err_free_lockers:ceph_free_lockers (*lockers, *num_lockers);return ret;
Signature · 1 line
2.53.0
net/ceph/cls_lock_client.c static int decode_lockers(void **p, void *end, u8 *type, char **tag,
Quoted 90 lines · Pavitra Jha
ceph_start_decoding()accepts struct_len=0 as valid:ceph_decode_need(p, end, 0, bad)always passes. When a malicious or compromised OSD sends acls_lock_get_info_replywith struct_len=0,ceph_start_decoding()returns success with p == end, leaving zero bytes guaranteed for subsequent reads.The immediately following bare
ceph_decode_32(p)indecode_lockers()has no preceding bounds check. With p == end this is a 4-byte read past the validated buffer boundary. The garbage value is then passed tokzalloc_objs()as the locker count.The sibling function
decode_watchers()inosd_client.calready uses the safe variantceph_decode_32_safe()after its ownceph_start_decoding()call.decode_lockers()is the only site using the bare variant, confirming an oversight.Fix by replacing
ceph_decode_32(p)withceph_decode_32_safe(p, end, *num_lockers, err_inval), adding a newerr_invallabel that returns-EINVALdirectly without attempting to free an uninitialized lockers pointer.KASAN report (kernel 7.0.0-rc7, QEMU/x86_64, KASLR disabled):
==================================================================BUG: KASAN: slab-out-of-bounds in ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc] Read of size 4 at addr ffff88800a29b76e by task insmod/58 CPU: 0 UID: 0 PID: 58 Comm: insmod Tainted: G O 7.0.0-rc7-g9c2abf69da83-dirty #15 PREEMPT(lazy) Tainted: [O]=OOT_MODULE Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0-debian-1.17.0-1 04/01/2014 Call Trace: <TASK> dump_stack_lvl+0x4d/0x70 print_report+0x170/0x4f3 kasan_report+0xda/0x110 ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc] do_one_initcall+0x9a/0x3a0 do_init_module+0x27c/0x790 load_module+0x4a9a/0x6350 init_module_from_file+0x15c/0x180 idempotent_init_module+0x21f/0x750 __x64_sys_finit_module+0xba/0x120 do_syscall_64+0xe2/0x570 entry_SYSCALL_64_after_hwframe+0x77/0x7f Allocated by task 58: kasan_save_stack+0x30/0x50 kasan_save_track+0x14/0x30 __kasan_kmalloc+0x7f/0x90 ceph_oob3_init+0x4d/0xff0 [ceph_oob3_poc] do_one_initcall+0x9a/0x3a0 do_init_module+0x27c/0x790 load_module+0x4a9a/0x6350 init_module_from_file+0x15c/0x180 idempotent_init_module+0x21f/0x750 __x64_sys_finit_module+0xba/0x120 do_syscall_64+0xe2/0x570 entry_SYSCALL_64_after_hwframe+0x77/0x7f The buggy address belongs to the object at ffff88800a29a000 which belongs to the cache kmalloc-8k of size 8192 The buggy address is located 5998 bytes inside of allocated 6000-byte region [ffff88800a29a000, ffff88800a29b770) Memory state around the buggy address: ffff88800a29b600: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ffff88800a29b680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 >ffff88800a29b700: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 fc fc ^ ffff88800a29b780: fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc ==================================================================num_lockers=0xccccaaaa (OOB garbage from KASAN redzone)
Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment can trigger this against any kernel client that issues the lock.get_info class method (e.g. during RBD exclusive lock acquisition) without any further privileges beyond OSD session establishment.
Fixes d4ed4a530562 ("libceph: support for lock.lock_info")Signed-off-by Pavitra Jha <[email protected]>--- net/ceph/cls_lock_client.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)net/ceph/cls_lock_client.c +0
-0@@ -299,7 +299,7 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag,
As far as I can see, decode_locker() has the same issue. Have you sent the patch for this?
Quoted 9 lines
net/ceph/cls_lock_client.c +1
-1if (ret)return ret; - *num_lockers =ceph_decode_32 (p); +ceph_decode_32_safe (p, end, *num_lockers, err_inval); *lockers =kzalloc_objs (**lockers, *num_lockers,GFP_NOIO );if (!*lockers)return -ENOMEM ;
net/ceph/cls_lock_client.c static int decode_lockers(void **p, void *end, u8 *type, char **tag, · line 327
Quoted 8 lines
net/ceph/cls_lock_client.c +2
-0@@ -320,6 +320,8 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, *tag = s;return 0 ; +err_inval: +return -EINVAL ; err_free_lockers:ceph_free_lockers (*lockers, *num_lockers);return ret;
I am still not completely sure about -EINVAL here too. Maybe, -ENOMEM could be more correct.
What about this [1]?
*type = ceph_decode_8(p);
Should we rework it too?
Thanks,
Slava.
[1]
https://elixir.bootlin.com/linux/v7.1-rc4/source/net/ceph/cls_lock_client.c#L313
PATCH v2 1/1 ceph: fix bare ceph_decode_8 OOB in decode_lockers()
decode_lockers() in cls_lock_client.c contains a bare ceph_decode_8(p) call after the decode_locker() loop that has no preceding bounds check.
If a malicious or compromised OSD sends a cls_lock_get_info_reply where num_lockers is crafted such that the decode_locker() loop advances p exactly to end (or if num_lockers=0 and p is already at end after ceph_start_decoding() accepts struct_len=0), the subsequent bare ceph_decode_8(p) reads one byte past the validated buffer boundary.
The result is passed directly into *type, which is subsequently used as a lock type discriminator by callers. An OSD-controlled one-byte OOB read at this position gives an attacker influence over the lock type field with no further preconditions.
The safe variant ceph_decode_8_safe() already exists and is used consistently throughout the codebase. This site is the only remaining bare ceph_decode_8() in the decode_lockers() post-loop path.
The goto target is err_free_lockers (not err_inval) because *lockers is already allocated at this point and must be freed on any decode failure.
v1 of this series fixed the bare ceph_decode_32() before kzalloc_objs() and added the err_inval label. This v2 addresses the second bare decode identified by Viacheslav Dubeyko's review.
Regarding the -EINVAL choice (raised in review): -EINVAL is correct for the err_inval path. The failure is structural malformation of OSD-supplied data, not a memory shortage. -ENOMEM would misrepresent the failure class to callers and to stable@ backporters triaging error paths.
Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment can trigger this against any kernel client that issues the lock.get_info class method (e.g. during RBD exclusive lock acquisition) without any further privileges beyond OSD session establishment.
---
v2: Replace bare *type = ceph_decode_8(p) with ceph_decode_8_safe(),
goto err_free_lockers to correctly free *lockers on failure. Address Viacheslav Dubeyko's review question about this site and clarify -EINVAL rationale.
--- net/ceph/cls_lock_client.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/ceph/cls_lock_client.c +1 -1
@@ -314,7 +314,7 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, goto err_free_lockers; } - *type =ceph_decode_8 (p); +ceph_decode_8_safe (p, end, *type, err_free_lockers); s =ceph_extract_encoded_string (p, end,NULL ,GFP_NOIO );if (IS_ERR (s)) { ret =PTR_ERR (s);
Signature · 1 line
2.53.0
Re: [PATCH v2] ceph: fix bare ceph_decode_8 OOB in decode_lockers()
Quoted 52 lines · Pavitra Jha
decode_lockers()incls_lock_client.ccontains a bareceph_decode_8(p)call after thedecode_locker()loop that has no preceding bounds check.If a malicious or compromised OSD sends a
cls_lock_get_info_replywherenum_lockersis crafted such that thedecode_locker()loop advances p exactly to end (or if num_lockers=0 and p is already at end afterceph_start_decoding()accepts struct_len=0), the subsequent bareceph_decode_8(p)reads one byte past the validated buffer boundary.The result is passed directly into *type, which is subsequently used as a lock type discriminator by callers. An OSD-controlled one-byte OOB read at this position gives an attacker influence over the lock type field with no further preconditions.
The safe variant
ceph_decode_8_safe()already exists and is used consistently throughout the codebase. This site is the only remaining bareceph_decode_8()in thedecode_lockers()post-loop path.The goto target is
err_free_lockers(noterr_inval) because *lockers is already allocated at this point and must be freed on any decode failure.v1 of this series fixed the bare
ceph_decode_32()beforekzalloc_objs()and added theerr_invallabel. This v2 addresses the second bare decode identified by Viacheslav Dubeyko's review.Regarding the
-EINVALchoice (raised in review):-EINVALis correct for theerr_invalpath. The failure is structural malformation of OSD-supplied data, not a memory shortage.-ENOMEMwould misrepresent the failure class to callers and to stable@ backporters triaging error paths.Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment can trigger this against any kernel client that issues the lock.get_info class method (e.g. during RBD exclusive lock acquisition) without any further privileges beyond OSD session establishment.
Fixes d4ed4a530562 ("libceph: support for lock.lock_info")Signed-off-by Pavitra Jha <[email protected]>---
v2: Replace bare *type =ceph_decode_8(p)withceph_decode_8_safe(),
gotoerr_free_lockersto correctly free *lockers on failure. Address Viacheslav Dubeyko's review question about this site and clarify-EINVALrationale.--- net/ceph/cls_lock_client.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)net/ceph/cls_lock_client.c +0
-0
net/ceph/cls_lock_client.c static int decode_lockers(void **p, void *end, u8 *type, char **tag, · line 320
Quoted 8 lines
net/ceph/cls_lock_client.c +1
-1@@ -314,7 +314,7 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, goto err_free_lockers; } - *type =ceph_decode_8 (p); +ceph_decode_8_safe (p, end, *type, err_free_lockers); s =ceph_extract_encoded_string (p, end,NULL ,GFP_NOIO );if (IS_ERR (s)) { ret =PTR_ERR (s);
Is it correct patch? Because, initial patch contained this:
net/ceph/cls_lock_client.c
Quoted 3 lines
net/ceph/cls_lock_client.c +1
-1- *num_lockers =ceph_decode_32 (p); +ceph_decode_32_safe (p, end, *num_lockers, err_inval); *lockers =kzalloc_objs (**lockers, *num_lockers,GFP_NOIO );
And I expected to see both modifications. I am slightly confused, frankly speaking.
Thanks,
Slava.
Dan Carpenter
build botRe: [PATCH v2] ceph: fix bare ceph_decode_8 OOB in decode_lockers()
In reply to Pavitra JhaBCC: [email protected] CC: [email protected] In-Reply-To: <[email protected]> References: <[email protected]> TO: Pavitra Jha…
BCC: [email protected]
CC: [email protected]
In-Reply-To: <[email protected]>
References: <[email protected]>
TO: Pavitra Jha <[email protected]>
TO: [email protected]
CC: [email protected]
CC: [email protected]
CC: [email protected]
CC: [email protected]
CC: [email protected]
CC: Pavitra Jha <[email protected]>
Hi Pavitra,
kernel test robot noticed the following build warnings:
[auto build test WARNING on ceph-client/testing]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Pavitra-Jha/ceph-fix-bare-ceph_decode_8-OOB-in-decode_lockers/20260528-212749 base: https://github.com/ceph/ceph-client.git testing patch link: https://lore.kernel.org/r/20260528132521.843004-1-jhapavitra98%40gmail.com patch subject: [PATCH v2] ceph: fix bare ceph_decode_8 OOB in decode_lockers()
:::::: branch date: 2 days ago
:::::: commit date: 2 days ago
config: um-randconfig-r073-20260530 (https://download.01.org/0day-ci/archive/20260531/[email protected]/config)
compiler: gcc-14 (Debian 14.2.0-19) 14.2.0
smatch: v0.5.0-9185-gbcc58b9c
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]> | Reported-by: Dan Carpenter <[email protected]> | Closes: https://lore.kernel.org/r/[email protected]/
smatch warnings:net/ceph/cls_lock_client.c:313 decode_lockers() warn: missing error code 'ret'
vim +/ret +313 net/ceph/cls_lock_client.c
d4ed4a53056288 Douglas Fuller 2015-06-29 287
d4ed4a53056288 Douglas Fuller 2015-06-29 288 static int decode_lockers(void **p, void *end, u8 *type, char **tag,
d4ed4a53056288 Douglas Fuller 2015-06-29 289 struct ceph_locker **lockers, u32 *num_lockers)
d4ed4a53056288 Douglas Fuller 2015-06-29 290 {
d4ed4a53056288 Douglas Fuller 2015-06-29 291 u8 struct_v;
d4ed4a53056288 Douglas Fuller 2015-06-29 292 u32 struct_len;
d4ed4a53056288 Douglas Fuller 2015-06-29 293 char *s;
d4ed4a53056288 Douglas Fuller 2015-06-29 294 int i;
d4ed4a53056288 Douglas Fuller 2015-06-29 295 int ret;
d4ed4a53056288 Douglas Fuller 2015-06-29 296
d4ed4a53056288 Douglas Fuller 2015-06-29 297 ret = ceph_start_decoding(p, end, 1, "cls_lock_get_info_reply",
d4ed4a53056288 Douglas Fuller 2015-06-29 298 &struct_v, &struct_len);
d4ed4a53056288 Douglas Fuller 2015-06-29 299 if (ret)
d4ed4a53056288 Douglas Fuller 2015-06-29 300 return ret;
d4ed4a53056288 Douglas Fuller 2015-06-29 301
d4ed4a53056288 Douglas Fuller 2015-06-29 302 *num_lockers = ceph_decode_32(p);
69050f8d6d075d Kees Cook 2026-02-20 303 *lockers = kzalloc_objs(**lockers, *num_lockers, GFP_NOIO);
d4ed4a53056288 Douglas Fuller 2015-06-29 304 if (!*lockers)
d4ed4a53056288 Douglas Fuller 2015-06-29 305 return -ENOMEM;
d4ed4a53056288 Douglas Fuller 2015-06-29 306
d4ed4a53056288 Douglas Fuller 2015-06-29 307 for (i = 0; i < *num_lockers; i++) {
d4ed4a53056288 Douglas Fuller 2015-06-29 308 ret = decode_locker(p, end, *lockers + i);
d4ed4a53056288 Douglas Fuller 2015-06-29 309 if (ret)
d4ed4a53056288 Douglas Fuller 2015-06-29 310 goto err_free_lockers;
d4ed4a53056288 Douglas Fuller 2015-06-29 311 }
d4ed4a53056288 Douglas Fuller 2015-06-29 312
cff58e4599d8e1 Pavitra Jha 2026-05-28 @313 ceph_decode_8_safe(p, end, *type, err_free_lockers);
d4ed4a53056288 Douglas Fuller 2015-06-29 314 s = ceph_extract_encoded_string(p, end, NULL, GFP_NOIO);
d4ed4a53056288 Douglas Fuller 2015-06-29 315 if (IS_ERR(s)) {
d4ed4a53056288 Douglas Fuller 2015-06-29 316 ret = PTR_ERR(s);
d4ed4a53056288 Douglas Fuller 2015-06-29 317 goto err_free_lockers;
d4ed4a53056288 Douglas Fuller 2015-06-29 318 }
d4ed4a53056288 Douglas Fuller 2015-06-29 319
d4ed4a53056288 Douglas Fuller 2015-06-29 320 *tag = s;
d4ed4a53056288 Douglas Fuller 2015-06-29 321 return 0;
d4ed4a53056288 Douglas Fuller 2015-06-29 322
d4ed4a53056288 Douglas Fuller 2015-06-29 323 err_free_lockers:
d4ed4a53056288 Douglas Fuller 2015-06-29 324 ceph_free_lockers(*lockers, *num_lockers);
d4ed4a53056288 Douglas Fuller 2015-06-29 325 return ret;
d4ed4a53056288 Douglas Fuller 2015-06-29 326 }
d4ed4a53056288 Douglas Fuller 2015-06-29 327 --
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
PATCH v3 1/1 ceph: fix two unsafe bare decodes in decode_lockers()
decode_lockers() in cls_lock_client.c contains two bare decode operations that allow a malicious or compromised OSD to trigger slab-out-of-bounds reads:
1. ceph_decode_32(p) at the num_lockers field has no preceding bounds check. ceph_start_decoding() accepts struct_len=0 as valid -- the internal ceph_decode_need(p, end, 0, bad) always passes -- so when an OSD sends struct_len=0, ceph_start_decoding() returns success with p == end. The immediately following bare ceph_decode_32(p) then reads 4 bytes past the validated buffer boundary. The garbage value is passed directly to kzalloc_objs() as the locker count.
The sibling function decode_watchers() in osd_client.c already uses ceph_decode_32_safe() after its own ceph_start_decoding() call. decode_lockers() was the only site using the bare variant.
2. ceph_decode_8(p) after the decode_locker() loop has no preceding bounds check. If an OSD crafts num_lockers such that the loop advances p exactly to end, the subsequent bare ceph_decode_8(p) reads one byte past the validated buffer boundary. The result is passed directly into *type, which is used as a lock type discriminator by callers, giving an OSD-controlled one-byte OOB read with direct influence over the lock type field.
Fix both by replacing bare operations with their safe variants:
ceph_decode_32(p) -> ceph_decode_32_safe(p, end, *num_lockers,
err_inval)
ceph_decode_8(p) -> ceph_decode_8_safe(p, end, *type,
err_free_lockers)
The goto targets differ intentionally:
err_inval: is a new label returning -EINVAL directly. It is used for the pre-allocation failure path where *lockers is not yet allocated and must not be passed to ceph_free_lockers().
err_free_lockers: is the existing label. It is used for the post-allocation failure path where *lockers is allocated and must be freed.
ret is set to -EINVAL before ceph_decode_8_safe() so that err_free_lockers returns the correct error code on bounds violation. Without this, err_free_lockers would return a stale ret value (0 from the successful decode_locker() loop), silently swallowing the error.
-EINVAL is correct for both failure paths. The data received from the OSD is structurally malformed. -ENOMEM would misrepresent the failure class to callers and to stable@ backporters triaging error paths.
KASAN report for bug 1 (kernel 7.0.0-rc7, QEMU/x86_64, KASLR disabled):
==================================================================
BUG: KASAN: slab-out-of-bounds in ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc]
Read of size 4 at addr ffff88800a29b76e by task insmod/58
CPU: 0 UID: 0 PID: 58 Comm: insmod Tainted: G O 7.0.0-rc7-g9c2abf69da83-dirty #15 PREEMPT(lazy)
Tainted: [O]=OOT_MODULE
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0-debian-1.17.0-1 04/01/2014
Call Trace:
<TASK>
dump_stack_lvl+0x4d/0x70
print_report+0x170/0x4f3
kasan_report+0xda/0x110
ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc]
do_one_initcall+0x9a/0x3a0
do_init_module+0x27c/0x790
load_module+0x4a9a/0x6350
init_module_from_file+0x15c/0x180
idempotent_init_module+0x21f/0x750
__x64_sys_finit_module+0xba/0x120
do_syscall_64+0xe2/0x570
entry_SYSCALL_64_after_hwframe+0x77/0x7f
Allocated by task 58:
kasan_save_stack+0x30/0x50
kasan_save_track+0x14/0x30
__kasan_kmalloc+0x7f/0x90
ceph_oob3_init+0x4d/0xff0 [ceph_oob3_poc]
do_one_initcall+0x9a/0x3a0
do_init_module+0x27c/0x790
load_module+0x4a9a/0x6350
init_module_from_file+0x15c/0x180
idempotent_init_module+0x21f/0x750
__x64_sys_finit_module+0xba/0x120
do_syscall_64+0xe2/0x570
entry_SYSCALL_64_after_hwframe+0x77/0x7f
The buggy address belongs to the object at ffff88800a29a000
which belongs to the cache kmalloc-8k of size 8192
The buggy address is located 5998 bytes inside of
allocated 6000-byte region [ffff88800a29a000, ffff88800a29b770)
Memory state around the buggy address:
ffff88800a29b600: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
ffff88800a29b680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
>ffff88800a29b700: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 fc fc
^
ffff88800a29b780: fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc
==================================================================num_lockers=0xccccaaaa (OOB garbage from KASAN redzone)
Bug 2 (ceph_decode_8) follows from the identical precondition. A dedicated PoC is available on request.
Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment can trigger this against any kernel client that issues the lock.get_info class method (e.g. during RBD exclusive lock acquisition) without any further privileges beyond OSD session establishment.
---
v3: Combine both fixes (ceph_decode_32 and ceph_decode_8) into a single
patch per Viacheslav Dubeyko's review. Set ret = -EINVAL before ceph_decode_8_safe() so err_free_lockers returns the correct error code, not stale ret (caught by Dan Carpenter / smatch). Clarify err_inval vs err_free_lockers goto selection rationale and -EINVAL justification.
--- net/ceph/cls_lock_client.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
net/ceph/cls_lock_client.c +5 -2
@@ -299,7 +299,7 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag,if (ret)return ret; - *num_lockers =ceph_decode_32 (p); +ceph_decode_32_safe (p, end, *num_lockers, err_inval); *lockers =kzalloc_objs (**lockers, *num_lockers,GFP_NOIO );if (!*lockers)return -ENOMEM ;
@@ -310,7 +310,8 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, goto err_free_lockers; } - *type =ceph_decode_8 (p); + ret = -EINVAL ; +ceph_decode_8_safe (p, end, *type, err_free_lockers); s =ceph_extract_encoded_string (p, end,NULL ,GFP_NOIO );if (IS_ERR (s)) { ret =PTR_ERR (s);
@@ -320,6 +321,8 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, *tag = s;return 0 ; +err_inval: +return -EINVAL ; err_free_lockers:ceph_free_lockers (*lockers, *num_lockers);return ret;
Signature · 1 line
2.53.0
Re: [PATCH v3] ceph: fix two unsafe bare decodes in decode_lockers()
Quoted 168 lines · Pavitra Jha
decode_lockers()incls_lock_client.ccontains two bare decode operations
that allow a malicious or compromised OSD to trigger slab-out-of- bounds
reads:1.
ceph_decode_32(p)at thenum_lockersfield has no preceding bounds check.ceph_start_decoding()accepts struct_len=0 as valid -- the internalceph_decode_need(p, end, 0, bad)always passes -- so when an
OSD sends struct_len=0,ceph_start_decoding()returns success with p == end. The immediately following bareceph_decode_32(p)then reads
4 bytes past the validated buffer boundary. The garbage value is passed directly tokzalloc_objs()as the locker count.The sibling function
decode_watchers()inosd_client.calready uses
ceph_decode_32_safe()after its ownceph_start_decoding()call.decode_lockers()was the only site using the bare variant.2.
ceph_decode_8(p)after thedecode_locker()loop has no preceding bounds check. If an OSD craftsnum_lockerssuch that the loop advances p exactly to end, the subsequent bareceph_decode_8(p)reads
one byte past the validated buffer boundary. The result is passed directly into *type, which is used as a lock type discriminator by callers, giving an OSD-controlled one-byte OOB read with direct influence over the lock type field.Fix both by replacing bare operations with their safe variants:
ceph_decode_32(p)->ceph_decode_32_safe(p, end, *num_lockers, err_inval)ceph_decode_8(p) ->ceph_decode_8_safe(p, end, *type, err_free_lockers)The goto targets differ intentionally:
err_inval: is a new label returning-EINVALdirectly. It is used for
the pre-allocation failure path where *lockers is not yet allocated and must not be passed toceph_free_lockers().
err_free_lockers: is the existing label. It is used for the post-allocation failure path where *lockers is allocated and must be freed.ret is set to
-EINVALbeforeceph_decode_8_safe()so thaterr_free_lockersreturns the correct error code on bounds violation. Without this,err_free_lockerswould return a stale ret value (0 from the successfuldecode_locker()loop), silently swallowing the error.
-EINVALis correct for both failure paths. The data received from the OSD is structurally malformed.-ENOMEMwould misrepresent the failure class to callers and to stable@ backporters triaging error paths.KASAN report for bug 1 (kernel 7.0.0-rc7, QEMU/x86_64, KASLR disabled):
==================================================================BUG: KASAN: slab-out-of-bounds in ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc] Read of size 4 at addr ffff88800a29b76e by task insmod/58 CPU: 0 UID: 0 PID: 58 Comm: insmod Tainted: G O 7.0.0-rc7-g9c2abf69da83-dirty #15 PREEMPT(lazy) Tainted: [O]=OOT_MODULE Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0- debian-1.17.0-1 04/01/2014 Call Trace: <TASK> dump_stack_lvl+0x4d/0x70 print_report+0x170/0x4f3 kasan_report+0xda/0x110 ceph_oob3_init+0x251/0xff0 [ceph_oob3_poc] do_one_initcall+0x9a/0x3a0 do_init_module+0x27c/0x790 load_module+0x4a9a/0x6350 init_module_from_file+0x15c/0x180 idempotent_init_module+0x21f/0x750 __x64_sys_finit_module+0xba/0x120 do_syscall_64+0xe2/0x570 entry_SYSCALL_64_after_hwframe+0x77/0x7f Allocated by task 58: kasan_save_stack+0x30/0x50 kasan_save_track+0x14/0x30 __kasan_kmalloc+0x7f/0x90 ceph_oob3_init+0x4d/0xff0 [ceph_oob3_poc] do_one_initcall+0x9a/0x3a0 do_init_module+0x27c/0x790 load_module+0x4a9a/0x6350 init_module_from_file+0x15c/0x180 idempotent_init_module+0x21f/0x750 __x64_sys_finit_module+0xba/0x120 do_syscall_64+0xe2/0x570 entry_SYSCALL_64_after_hwframe+0x77/0x7f The buggy address belongs to the object at ffff88800a29a000which belongs to the cache kmalloc-8k of size 8192 The buggy address is located 5998 bytes inside of allocated 6000-byte region [
ffff88800a29a000,ffff88800a29b770)Memory state around the buggy address: ffff88800a29b600: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ffff88800a29b680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 >ffff88800a29b700: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 fc fc^
ffff88800a29b780: fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc
==================================================================num_lockers=0xccccaaaa (OOB garbage from KASAN redzone)
Bug 2 (
ceph_decode_8) follows from the identical precondition. A dedicated PoC is available on request.Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment can trigger this against any kernel client that issues the lock.get_info class method (e.g. during RBD exclusive lock acquisition)
without any further privileges beyond OSD session establishment.Fixes d4ed4a530562 ("libceph: support for lock.lock_info")Signed-off-by Pavitra Jha <[email protected]>---
v3: Combine both fixes (ceph_decode_32andceph_decode_8) into a single
patch per Viacheslav Dubeyko's review. Set ret =-EINVALbeforeceph_decode_8_safe()soerr_free_lockersreturns the correct error
code, not stale ret (caught by Dan Carpenter / smatch). Clarifyerr_invalvserr_free_lockersgoto selection rationale and-EINVALjustification.
---
net/ceph/cls_lock_client.c | 7 +++++--1 file changed, 5 insertions(+), 2 deletions(-)net/ceph/cls_lock_client.c +0
-0@@ -299,7 +299,7 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, if (ret) return ret;net/ceph/cls_lock_client.c +1
-1- *num_lockers =ceph_decode_32 (p); +ceph_decode_32_safe (p, end, *num_lockers, err_inval);*lockers =
kzalloc_objs(**lockers, *num_lockers, GFP_NOIO); if (!*lockers)
return-ENOMEM;net/ceph/cls_lock_client.c +0
-0@@ -310,7 +310,8 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, goto err_free_lockers; }net/ceph/cls_lock_client.c +2
-1- *type =ceph_decode_8 (p); + ret = -EINVAL ; +ceph_decode_8_safe (p, end, *type, err_free_lockers);s =
ceph_extract_encoded_string(p, end, NULL, GFP_NOIO); if (IS_ERR(s)) {
ret =PTR_ERR(s);net/ceph/cls_lock_client.c +0
-0@@ -320,6 +321,8 @@ static int decode_lockers(void **p, void *end, u8 *type, char **tag, *tag = s; return 0;net/ceph/cls_lock_client.c +2
-0+err_inval: +return -EINVAL ;
Quoted 3 lines
err_free_lockers:
ceph_free_lockers(*lockers, *num_lockers); return ret;
Looks good.
Thanks,
Slava.
The follow-up patch titled:
"[PATCH v2] ceph: fix bare ceph_decode_8 OOB in decode_lockers()"
was intended as the continuation of this review thread and addresses the additional bare decode site pointed out by Slava here:
*type = ceph_decode_8(p);
I accidentally sent it as a separate thread instead of a reply to this discussion.
Thanks,
Pavitra