mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-03 10:10:33 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

bpf: Fix theoretical prog_array UAF in __uprobe_perf_func()

Browse source 
Currently, the pointer stored in call->prog_array is loaded in
__uprobe_perf_func(), with no RCU annotation and no immediately visible
RCU protection, so it looks as if the loaded pointer can immediately be
dangling.
Later, bpf_prog_run_array_uprobe() starts a RCU-trace read-side critical
section, but this is too late. It then uses rcu_dereference_check(), but
this use of rcu_dereference_check() does not actually dereference anything.

Fix it by aligning the semantics to bpf_prog_run_array(): Let the caller
provide rcu_read_lock_trace() protection and then load call->prog_array
with rcu_dereference_check().

This issue seems to be theoretical: I don't know of any way to reach this
code without having handle_swbp() further up the stack, which is already
holding a rcu_read_lock_trace() lock, so where we take
rcu_read_lock_trace() in __uprobe_perf_func()/bpf_prog_run_array_uprobe()
doesn't actually have any effect.

Fixes: 8c7dcb84e3 ("bpf: implement sleepable uprobes by chaining gps")
Suggested-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Jann Horn <jannh@google.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/bpf/20241210-bpf-fix-uprobe-uaf-v4-1-5fc8959b2b74@google.com
This commit is contained in:
Jann Horn 2024-12-10 20:08:14 +01:00 committed by Andrii Nakryiko
parent c4441ca86a
commit 7d0d673627
2 changed files with 10 additions and 9 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

13
include/linux/bpf.h
View file

@ -2194,26 +2194,25 @@ bpf_prog_run_array(const struct bpf_prog_array *array,
* rcu-protected dynamically sized maps. * rcu-protected dynamically sized maps.
*/ */
static __always_inline u32 static __always_inline u32
bpf_prog_run_array_uprobe(const struct bpf_prog_array __rcu *array_rcu, bpf_prog_run_array_uprobe(const struct bpf_prog_array *array,
const void *ctx, bpf_prog_run_fn run_prog) const void *ctx, bpf_prog_run_fn run_prog)
{ {
const struct bpf_prog_array_item *item; const struct bpf_prog_array_item *item;
const struct bpf_prog *prog; const struct bpf_prog *prog;
const struct bpf_prog_array *array;
struct bpf_run_ctx *old_run_ctx; struct bpf_run_ctx *old_run_ctx;
struct bpf_trace_run_ctx run_ctx; struct bpf_trace_run_ctx run_ctx;
u32 ret = 1; u32 ret = 1;
might_fault(); might_fault();
RCU_LOCKDEP_WARN(!rcu_read_lock_trace_held(), "no rcu lock held");
if (unlikely(!array))
return ret;
rcu_read_lock_trace();
migrate_disable(); migrate_disable();
run_ctx.is_uprobe = true; run_ctx.is_uprobe = true;
array = rcu_dereference_check(array_rcu, rcu_read_lock_trace_held());
if (unlikely(!array))
goto out;
old_run_ctx = bpf_set_run_ctx(&run_ctx.run_ctx); old_run_ctx = bpf_set_run_ctx(&run_ctx.run_ctx);
item = &array->items[0]; item = &array->items[0];
while ((prog = READ_ONCE(item->prog))) { while ((prog = READ_ONCE(item->prog))) {
@ -2228,9 +2227,7 @@ bpf_prog_run_array_uprobe(const struct bpf_prog_array __rcu *array_rcu,
rcu_read_unlock(); rcu_read_unlock();
} }
bpf_reset_run_ctx(old_run_ctx); bpf_reset_run_ctx(old_run_ctx);
out:
migrate_enable(); migrate_enable();
rcu_read_unlock_trace();
return ret; return ret;
} }

6
kernel/trace/trace_uprobe.c
View file

@ -1402,9 +1402,13 @@ static void __uprobe_perf_func(struct trace_uprobe *tu,
#ifdef CONFIG_BPF_EVENTS #ifdef CONFIG_BPF_EVENTS
if (bpf_prog_array_valid(call)) { if (bpf_prog_array_valid(call)) {
const struct bpf_prog_array *array;
u32 ret; u32 ret;
ret = bpf_prog_run_array_uprobe(call->prog_array, regs, bpf_prog_run); rcu_read_lock_trace();
array = rcu_dereference_check(call->prog_array, rcu_read_lock_trace_held());
ret = bpf_prog_run_array_uprobe(array, regs, bpf_prog_run);
rcu_read_unlock_trace();
if (!ret) if (!ret)
return; return;
} }