bpf: Fix UAF in bpf_trampoline_multi_attach_free on update failure
Subsystems (5)
PATCH v4 1/1 bpf: Fix UAF in bpf_trampoline_multi_attach_free on update failure
From: Hui Zhu <[email protected]>
When bpf_trampoline_update() fails before modify_fentry_multi()/ unregister_fentry_multi() is called, cur_image is unchanged (cur_image == old_image) and ftrace still calls into it. Freeing old_image in that case causes a UAF.
Only free old_image when it differs from cur_image.
Also change bpf_trampoline_multi_detach() to return void and drop the WARN_ON_ONCE at its call site.
---
Changelog:
v4:
According to the comments of bot+bpf-ci, add Fixes: and update comments of bpf_trampoline_multi_attach_free.
v3:
According to the comments of Jiri Olsa, drop patches 2/3 and the prog-side machinery.
keep only the simplified image-side fix in bpf_trampoline_multi_attach_free() and make bpf_trampoline_multi_detach() return void.
v2:
Folded v1's two detach patches into patch 1.
According to the comments of Jiri Olsa, Pin the prog (pinned_prog) on cur_image so it stays alive while ftrace may still call into it. Make bpf_trampoline_multi_detach() return void.
Fix the same UAF in standard (non-multi) trampolines. According to the comments of sashiko, Fix the prog UAF in bpf_trampoline_multi_attach() rollback.
Leak the trampoline in bpf_trampoline_put() when cur_image is left by a rollback.
include/linux/bpf.h | 9 ++++----- kernel/bpf/trampoline.c | 16 +++++++++++++--- kernel/trace/bpf_trace.c | 2 +- 3 files changed, 18 insertions(+), 9 deletions(-)
include/linux/bpf.h +4 -5
@@ -1518,8 +1518,8 @@ int arch_prepare_bpf_dispatcher(void *image, void *buf, s64 *funcs, int num_funcint bpf_trampoline_multi_attach (struct bpf_prog *prog,u32 *ids,struct bpf_tracing_multi_link *link); -int bpf_trampoline_multi_detach (struct bpf_prog *prog, -struct bpf_tracing_multi_link *link); +void bpf_trampoline_multi_detach (struct bpf_prog *prog, +struct bpf_tracing_multi_link *link);void bpf_trampoline_set_flags (struct bpf_trampoline *tr,u32 flags);/*
@@ -1639,10 +1639,9 @@ static inline int bpf_trampoline_multi_attach(struct bpf_prog *prog, u32 *ids, {return -ENOTSUPP ; } -static inline int bpf_trampoline_multi_detach (struct bpf_prog *prog, -struct bpf_tracing_multi_link *link) +static inline void bpf_trampoline_multi_detach (struct bpf_prog *prog, +struct bpf_tracing_multi_link *link) { -return -ENOTSUPP ; }static inline void bpf_trampoline_set_flags (struct bpf_trampoline *tr,u32 flags) {}#endif
kernel/bpf/trampoline.c +13 -3
@@ -1595,7 +1595,17 @@ static void bpf_trampoline_multi_attach_init(struct bpf_trampoline *tr)static void bpf_trampoline_multi_attach_free (struct bpf_trampoline *tr) { -if (tr->multi_attach.old_image) +/* +* Only free old_image if it is no longer the active image. +* When bpf_trampoline_update() fails before modify_fentry_multi()/ +* unregister_fentry_multi() is called, cur_image is unchanged +* (cur_image == old_image) and ftrace still points to it. Freeing +* it would cause a UAF when ftrace calls into the freed memory. +* On success, cur_image is either a new image or NULL, so +* old_image != cur_image means the image is stale. +*/ +if (tr->multi_attach.old_image && + tr->multi_attach.old_image != tr->cur_image)bpf_tramp_image_put (tr->multi_attach.old_image); tr->multi_attach.old_image =NULL ;
@@ -1719,7 +1729,8 @@ int bpf_trampoline_multi_attach(struct bpf_prog *prog, u32 *ids,return err; } -int bpf_trampoline_multi_detach (struct bpf_prog *prog,struct bpf_tracing_multi_link *link) +void bpf_trampoline_multi_detach (struct bpf_prog *prog, +struct bpf_tracing_multi_link *link) {struct bpf_tracing_multi_data *data = &link->data;struct bpf_tracing_multi_node *mnode;
@@ -1749,7 +1760,6 @@ int bpf_trampoline_multi_detach(struct bpf_prog *prog, struct bpf_tracing_multi_bpf_trampoline_put (mnode->trampoline);clear_tracing_multi_data (data); -return 0 ; }#undef for_each_mnode_cnt
kernel/trace/bpf_trace.c +1 -1
@@ -3687,7 +3687,7 @@ static void bpf_tracing_multi_link_release(struct bpf_link *link)struct bpf_tracing_multi_link *tr_link = container_of(link, struct bpf_tracing_multi_link, link); -WARN_ON_ONCE (bpf_trampoline_multi_detach (link->prog, tr_link)); +bpf_trampoline_multi_detach (link->prog, tr_link); }static void bpf_tracing_multi_link_dealloc (struct bpf_link *link)
Signature · 1 line
2.53.0
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Pre-existing issues:
- [High] Ignoring errors from __bpf_trampoline_unlink_prog() during detach leads to a Use-After-Free of the BPF program.
- [High] Ignoring errors from update_ftrace_direct_del/mod() during detach or attach rollback leads to a Use-After-Free of the trampoline image. --
--- Patch [1]: [PATCH v4] bpf: Fix UAF in bpf_trampoline_multi_attach_free on update failure --- commit 12049949b83ebddc54a6fdad57fa0b635706dbda
Author: Hui Zhu <[email protected]>
bpf: Fix UAF in bpf_trampoline_multi_attach_free on update failure
When bpf_trampoline_update() fails before modify_fentry_multi() or unregister_fentry_multi() is called, cur_image is unchanged and ftrace still calls into it. Freeing old_image in that case causes a UAF. This patch only frees old_image when it differs from cur_image, and makes bpf_trampoline_multi_detach() return void.
Quoted 10 lines
kernel/bpf/trampoline.c +1
-1@@ -1632,7 +1632,17 @@ static void bpf_trampoline_multi_attach_init(struct bpf_trampoline *tr)static void bpf_trampoline_multi_attach_free (struct bpf_trampoline *tr) { -if (tr->multi_attach.old_image) +/*
kernel/bpf/trampoline.c static void bpf_trampoline_multi_attach_init(struct bpf_trampoline *tr) · line 1645
Quoted 10 lines
kernel/bpf/trampoline.c +10
-0+* Only free old_image if it is no longer the active image. +* When bpf_trampoline_update() fails before modify_fentry_multi()/ +* unregister_fentry_multi() is called, cur_image is unchanged +* (cur_image == old_image) and ftrace still points to it. Freeing +* it would cause a UAF when ftrace calls into the freed memory. +* On success, cur_image is either a new image or NULL, so +* old_image != cur_image means the image is stale. +*/ +if (tr->multi_attach.old_image && + tr->multi_attach.old_image != tr->cur_image)
[Severity: High]
This is a pre-existing issue, but does this condition still allow a use-after-free of the trampoline image if ftrace updates fail?
If __bpf_trampoline_unlink_prog() succeeds in bpf_trampoline_multi_detach(), the active image is updated and old_image != cur_image will be true.
However, if the subsequent update to ftrace fails due to memory pressure:
if (ftrace_hash_count(data->unreg))
WARN_ON_ONCE(update_ftrace_direct_del(&direct_ops, data->unreg));ftrace will return an error without updating its hooks, leaving ftrace pointing to the original active image (old_image).
Since old_image != cur_image is true, won't bpf_trampoline_multi_attach_free() then free old_image while ftrace is still executing it?
A similar issue appears to exist during error rollback in kernel/bpf/trampoline.c:bpf_trampoline_multi_attach() if update_ftrace_direct_del() fails, leaving ftrace executing newly allocated images that are subsequently freed.
Quoted 3 lines
kernel/bpf/trampoline.c +0
-0bpf_tramp_image_put (tr->multi_attach.old_image); tr->multi_attach.old_image =NULL ;
[ ... ]
kernel/trace/bpf_trace.c static void bpf_tracing_multi_link_release(struct bpf_link *link) · line 3690
Quoted 10 lines
kernel/trace/bpf_trace.c +1
-1@@ -3687,7 +3687,7 @@ static void bpf_tracing_multi_link_release(struct bpf_link *link)struct bpf_tracing_multi_link *tr_link = container_of(link, struct bpf_tracing_multi_link, link); -WARN_ON_ONCE (bpf_trampoline_multi_detach (link->prog, tr_link)); +bpf_trampoline_multi_detach (link->prog, tr_link);
[Severity: High]
This is a pre-existing issue, but does dropping the program reference here lead to a use-after-free if __bpf_trampoline_unlink_prog() fails?
In kernel/bpf/trampoline.c:bpf_trampoline_multi_detach(), if unlink fails:
err = __bpf_trampoline_unlink_prog(&mnode->node, mnode->trampoline, NULL,
&trampoline_multi_ops, data);
WARN_ONCE(err, "__bpf_trampoline_unlink_prog failed: %d\n", err);the detach path ignores the error. The ftrace direct hook remains active and the active trampoline image remains unchanged, keeping its hardcoded call to the BPF program.
Since bpf_tracing_multi_link_release() proceeds to drop the link's reference to the BPF program, if the program's refcount drops to zero and it is freed, could ftrace continue to jump into the freed program?
Quoted 3 lines
kernel/trace/bpf_trace.c +0
-0}static void bpf_tracing_multi_link_dealloc (struct bpf_link *link)
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
[email protected]
AI reviewThis isn't a bug, but would it be worth splitting the return-type change into its own patch?
Quoted 12 lines
include/linux/bpf.h +2
-2@@ -1518,8 +1518,8 @@ int arch_prepare_bpf_dispatcher(void *image, void *buf, s64 *funcs, int num_funcint bpf_trampoline_multi_attach (struct bpf_prog *prog,u32 *ids,struct bpf_tracing_multi_link *link); -int bpf_trampoline_multi_detach (struct bpf_prog *prog, -struct bpf_tracing_multi_link *link); +void bpf_trampoline_multi_detach (struct bpf_prog *prog, +struct bpf_tracing_multi_link *link);
[ ... ]
Quoted 4 lines
kernel/bpf/trampoline.c +0
-0
[ ... ]
Quoted 7 lines
kernel/bpf/trampoline.c +2
-1@@ -1756,7 +1766,8 @@ int bpf_trampoline_multi_attach(struct bpf_prog *prog, u32 *ids,return err; } -int bpf_trampoline_multi_detach (struct bpf_prog *prog,struct bpf_tracing_multi_link *link) +void bpf_trampoline_multi_detach (struct bpf_prog *prog, +struct bpf_tracing_multi_link *link)
[ ... ]
kernel/trace/bpf_trace.c static void bpf_tracing_multi_link_release(struct bpf_link *link) · line 3691
Quoted 11 lines
kernel/trace/bpf_trace.c +1
-1@@ -3687,7 +3687,7 @@ static void bpf_tracing_multi_link_release(struct bpf_link *link)struct bpf_tracing_multi_link *tr_link = container_of(link, struct bpf_tracing_multi_link, link); -WARN_ON_ONCE (bpf_trampoline_multi_detach (link->prog, tr_link)); +bpf_trampoline_multi_detach (link->prog, tr_link); }
This isn't a bug, but would it be worth splitting the return-type change into its own patch?
The int-to-void conversion of bpf_trampoline_multi_detach() touches both bpf.h prototypes, the definition and the bpf_trace.c call site, but is independent of the old_image lifetime fix that the Fixes: tag refers to.
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/31362089875