selftests/bpf: Add tests for pointer type merge at a shared load
Subsystems (3)
Daniel Borkmann
maintainerPATCH v3 1/3 selftests/bpf: Add tests for pointer type merge at a shared load
Cover the ways in which the type recorded for a shared load used to lose the BPF_PROBE_MEM rewrite which would then trigger a NULL deref if not handled properly.
# LDLIBS=-static PKG_CONFIG='pkg-config --static' ./vmtest.sh -- ./test_progs -t mem_rdonly_untrusted [...]
#242/1 mem_rdonly_untrusted/btf_id_to_ptr_mem:OK #242/2 mem_rdonly_untrusted/ldx_is_ok_bad_addr:OK #242/3 mem_rdonly_untrusted/ldx_is_ok_good_addr:OK #242/4 mem_rdonly_untrusted/offset_not_tracked:OK #242/5 mem_rdonly_untrusted/stx_not_ok:OK #242/6 mem_rdonly_untrusted/atomic_not_ok:OK #242/7 mem_rdonly_untrusted/atomic_rmw_not_ok:OK #242/8 mem_rdonly_untrusted/kfunc_param_not_ok:OK #242/9 mem_rdonly_untrusted/mixed_mem_type:OK #242/10 mem_rdonly_untrusted/mixed_mem_untrusted_btf_id_type:OK #242/11 mem_rdonly_untrusted/mixed_mem_btf_id_type:OK #242/12 mem_rdonly_untrusted/mixed_rdonly_mem_btf_id_type:OK #242/13 mem_rdonly_untrusted/mixed_mem_mem_type:OK #242/14 mem_rdonly_untrusted/mixed_map_value_mem_type:OK #242/15 mem_rdonly_untrusted/mixed_stack_mem_type:OK #242/16 mem_rdonly_untrusted/diff_size_access:OK #242/17 mem_rdonly_untrusted/misaligned_access:OK #242/18 mem_rdonly_untrusted/null_check:OK #242/19 mem_rdonly_untrusted/ldx_is_ok_commuted_addr:OK #242/20 mem_rdonly_untrusted/helper_param_not_ok:OK #242 mem_rdonly_untrusted:OK
Summary: 1/20 PASSED, 0 SKIPPED, 0/0 FAILED
---
v2->v3:
- address GCC-BPF failure (Eduard, CI)
.../bpf/progs/mem_rdonly_untrusted.c | 234 ++++++++++++++++++ 1 file changed, 234 insertions(+)
tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c +234 -0
@@ -3,6 +3,7 @@#include <vmlinux.h> #include <bpf/bpf_core_read.h> #include "bpf_misc.h" +#include "bpf_kfuncs.h" #include "../test_kmods/bpf_testmod_kfunc.h" SEC ("tp_btf/sys_enter" )
@@ -164,6 +165,239 @@ int mixed_mem_type(void *ctx)return *p; } +struct { + __uint(type, BPF_MAP_TYPE_RINGBUF); + __uint(max_entries, 4096); +} ringbuf SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_ARRAY); + __uint(max_entries, 1); + __type(key, u32); + __type(value, u64); +} array SEC(".maps"); + +char dynptr_data[8 ]; + +int zero; + +SEC("socket") +__success +__log_level(2) +__msg("r8 = *(u64 *)(r7 +0){{.*}}R7=untrusted_ptr_sock") +__msg("r8 = *(u64 *)(r7 +0){{.*}}R7=ringbuf_mem") +__retval(0) +int mixed_mem_untrusted_btf_id_type (void *ctx) +{ +u64 *p, *q, v; + + p =bpf_ringbuf_reserve (&ringbuf,sizeof (*p),0 ); +if (!p) +return 1 ; + *p =42 ; + q = bpf_rdonly_cast(0, bpf_core_type_id_kernel(struct sock)); +/* +* The load below is reached with PTR_TO_MEM | MEM_RINGBUF on one +* path and with PTR_TO_BTF_ID | PTR_UNTRUSTED on the other. The +* merged type has to keep the BPF_PROBE_MEM rewrite, otherwise +* the NULL deref taken at runtime panics the kernel instead of +* returning 0. +*/ + asmvolatile ( +"r7 = %[p];" +"if %[zero] != 0 goto +1;" +"r7 = %[q];" +"r8 = *(u64 *)(r7 + 0);" +"%[v] = r8;" + : [v]"=r" (v) + : [p]"r" (p), + [q]"r" (q), + [zero]"r" (zero) + :"r7" ,"r8" ); +bpf_ringbuf_discard (p,0 ); +return v; +} + +SEC("socket") +__success +__log_level(2) +__msg("r8 = *(u32 *)(r7 +0){{.*}}R7=ptr_nameidata") +__msg("r8 = *(u32 *)(r7 +0){{.*}}R7=ringbuf_mem") +__retval(0) +int mixed_mem_btf_id_type (void *ctx) +{ +struct task_struct *task; +u32 *p, *q; +u64 v; + + p =bpf_ringbuf_reserve (&ringbuf,sizeof (*p),0 ); +if (!p) +return 1 ; + *p =42 ; + task =bpf_get_current_task_btf (); +/* +* A plain BTF pointer walk yields a bare PTR_TO_BTF_ID, and +* task->nameidata is NULL unless the task currently is in the +* middle of a path lookup. +*/ + q = (u32 *)&task->nameidata->flags; +/* +* Same as above, except that the other path yields a bare +* PTR_TO_BTF_ID. Merging it with PTR_TO_MEM used to drop the +* BPF_PROBE_MEM rewrite the bare PTR_TO_BTF_ID would have +* gotten on its own. +*/ + asmvolatile ( +"r7 = %[p];" +"if %[zero] != 0 goto +1;" +"r7 = %[q];" +"r8 = *(u32 *)(r7 + 0);" +"%[v] = r8;" + : [v]"=r" (v) + : [p]"r" (p), + [q]"r" (q), + [zero]"r" (zero) + :"r7" ,"r8" ); +bpf_ringbuf_discard (p,0 ); +return v; +} + +SEC("socket") +__success +__log_level(2) +__msg("r8 = *(u32 *)(r7 +0){{.*}}R7=ptr_nameidata") +__msg("r8 = *(u32 *)(r7 +0){{.*}}R7=rdonly_mem") +__retval(0) +int mixed_rdonly_mem_btf_id_type (void *ctx) +{ +struct task_struct *task; +struct bpf_dynptr dptr; +char buf[sizeof (u32)]; +u32 *p, *q; +u64 v; + +if (bpf_dynptr_from_mem (dynptr_data,sizeof (dynptr_data),0 , &dptr)) +return 1 ; + p =bpf_dynptr_slice (&dptr,0 , buf,sizeof (buf)); +if (!p) +return 1 ; + task =bpf_get_current_task_btf (); + q = (u32 *)&task->nameidata->flags; +/* +* Same as above, except that the PTR_TO_MEM side already carries +* MEM_RDONLY. Merging it with a bare PTR_TO_BTF_ID used to yield +* PTR_TO_MEM | MEM_RDONLY, which is not rewritten either since +* only its PTR_UNTRUSTED variant is. +*/ + asmvolatile ( +"r7 = %[p];" +"if %[zero] != 0 goto +1;" +"r7 = %[q];" +"r8 = *(u32 *)(r7 + 0);" +"%[v] = r8;" + : [v]"=r" (v) + : [p]"r" (p), + [q]"r" (q), + [zero]"r" (zero) + :"r7" ,"r8" ); +return v; +} + +SEC("socket") +__success +__log_level(2) +__msg("r8 = *(u64 *)(r7 +0){{.*}}R7=ringbuf_mem") +__msg("r8 = *(u64 *)(r7 +0){{.*}}R7=rdonly_untrusted_mem") +__retval(0) +int mixed_mem_mem_type (void *ctx) +{ +u64 *p, *q, v; + + p =bpf_ringbuf_reserve (&ringbuf,sizeof (*p),0 ); +if (!p) +return 1 ; + *p =42 ; + q =bpf_rdonly_cast (0 ,0 ); +/* +* Both paths are PTR_TO_MEM based, so they used to not trip the +* type mismatch check and skipped the merge altogether, leaving +* the insn with the PTR_TO_MEM | MEM_RINGBUF recorded first and +* hence without the BPF_PROBE_MEM rewrite the other path needs. +*/ + asmvolatile ( +"r7 = %[q];" +"if %[zero] == 0 goto +1;" +"r7 = %[p];" +"r8 = *(u64 *)(r7 + 0);" +"%[v] = r8;" + : [v]"=r" (v) + : [p]"r" (p), + [q]"r" (q), + [zero]"r" (zero) + :"r7" ,"r8" ); +bpf_ringbuf_discard (p,0 ); +return v; +} + +SEC("socket") +__failure +__msg("same insn cannot be used with different pointers") +int mixed_map_value_mem_type(void *ctx) +{ +u64 *p, *q, v; +u32 key =0 ; + + p =bpf_map_lookup_elem (&array, &key); +if (!p) +return 1 ; + q =bpf_rdonly_cast (0 ,0 ); +/* +* PTR_TO_MAP_VALUE is neither PTR_TO_MEM nor PTR_TO_BTF_ID based, +* so it cannot be merged into a type which keeps the BPF_PROBE_MEM +* rewrite the PTR_TO_MEM | MEM_RDONLY | PTR_UNTRUSTED of the other +* path needs. Both bases were mismatch ok, hence the load used to be +* accepted with the PTR_TO_MAP_VALUE recorded and the NULL deref on +* the second path panicked the kernel. +*/ + asmvolatile ( +"r7 = %[q];" +"if %[zero] == 0 goto +1;" +"r7 = %[p];" +"r8 = *(u64 *)(r7 + 0);" +"%[v] = r8;" + : [v]"=r" (v) + : [p]"r" (p), + [q]"r" (q), + [zero]"r" (zero) + :"r7" ,"r8" ); +return v; +} + +SEC("socket") +__failure +__msg("same insn cannot be used with different pointers") +int mixed_stack_mem_type(void *ctx) +{ +u64 *p =bpf_rdonly_cast (0 ,0 ); +u64 s =42 , v; + +/* +* Same as above, but for a PTR_TO_STACK on the other path. +*/ + asmvolatile ( +"r7 = %[p];" +"if %[zero] == 0 goto +1;" +"r7 = %[s];" +"r8 = *(u64 *)(r7 + 0);" +"%[v] = r8;" + : [v]"=r" (v) + : [p]"r" (p), + [s]"r" (&s), + [zero]"r" (zero) + :"r7" ,"r8" ); +return v; +} + __attribute__((__aligned__ (8 )))u8 global[] = {0x11 ,0x22 ,0x33 ,0x44 ,
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 2/3 selftests/bpf: Add tests for fault prone loads out of RCU pointers
Cover the two loads which used to lose the BPF_PROBE_MEM rewrite, both reached from an RCU read-side critical section. The purpose of this patch is to assert load success in order to make sure to not trigger verifier_bug_if() on bpf_may_fault_on_deref() due to forgotten rewrite of a probed pointer.
# LDLIBS=-static PKG_CONFIG='pkg-config --static' ./vmtest.sh -- ./test_progs -t rcu_read_lock [...]
#332/1 rcu_read_lock/success:OK #332/2 rcu_read_lock/rcuptr_acquire:OK #332/3 rcu_read_lock/negative_tests_inproper_region:OK #332/4 rcu_read_lock/negative_tests_rcuptr_misuse:OK #332 rcu_read_lock:OK
Summary: 1/4 PASSED, 0 SKIPPED, 0/0 FAILED
--- .../selftests/bpf/prog_tests/rcu_read_lock.c | 2 + .../selftests/bpf/progs/rcu_read_lock.c | 76 +++++++++++++++++++ 2 files changed, 78 insertions(+)
tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c +2 -0
@@ -34,6 +34,8 @@ static void test_success(void)bpf_program__set_autoload (skel->progs.rcu_read_lock_global_subprog, true);bpf_program__set_autoload (skel->progs.rcu_read_lock_subprog_lock, true);bpf_program__set_autoload (skel->progs.rcu_read_lock_subprog_unlock, true); +bpf_program__set_autoload (skel->progs.non_own_ref_untrusted_ld, true); +bpf_program__set_autoload (skel->progs.rcu_untrusted_union_ld, true); err =rcu_read_lock__load (skel);if (!ASSERT_OK (err,"skel_load" )) goto out;
tools/testing/selftests/bpf/progs/rcu_read_lock.c +76 -0
79 lines not on this page · raw message
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 3/3 selftests/bpf: Add tests for a store on a fault prone qdisc pointer
In reply to Daniel BorkmannCover the store which used to be left as a plain BPF_STX without an exception table entry:
1: R1=trusted_ptr_Qdisc() ; struct Qdisc *next = sch->next_sched; 1: (79) r1 = *(u64 *)(r1 +216) ; R1=ptr_Qdisc() ; next->limit = 1000; 3: (63) *(u32 *)(r1 +20) = r2 ; R1=ptr_Qdisc() R2=1000
Assert that it is rejected now.
# LDLIBS=-static PKG_CONFIG='pkg-config --static' ./vmtest.sh -- ./test_progs -t ns_bpf_qdisc [...]
#257/1 ns_bpf_qdisc/fifo:OK #257/2 ns_bpf_qdisc/fq:OK #257/3 ns_bpf_qdisc/attach to mq:OK #257/4 ns_bpf_qdisc/attach to non root:OK #257/5 ns_bpf_qdisc/incompl_ops:OK #257/6 ns_bpf_qdisc/invalid_dynptr:OK #257/7 ns_bpf_qdisc/invalid_dynptr_cross_frame:OK #257/8 ns_bpf_qdisc/invalid_dynptr_slice:OK #257/9 ns_bpf_qdisc/untrusted_write:OK #257/10 ns_bpf_qdisc/dynptr_use_after_invalidate_clone:OK #257 ns_bpf_qdisc:OK
Summary: 1/10 PASSED, 0 SKIPPED, 0/0 FAILED
---
v2->v3:
- new patch
.../selftests/bpf/prog_tests/bpf_qdisc.c | 2 + .../progs/bpf_qdisc_fail__untrusted_write.c | 65 +++++++++++++++++++ 2 files changed, 67 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/bpf_qdisc_fail__untrusted_write.c
tools/testing/selftests/bpf/prog_tests/bpf_qdisc.c +2 -0
@@ -11,6 +11,7 @@#include "bpf_qdisc_fail__invalid_dynptr.skel.h" #include "bpf_qdisc_fail__invalid_dynptr_slice.skel.h" #include "bpf_qdisc_fail__invalid_dynptr_cross_frame.skel.h" +#include "bpf_qdisc_fail__untrusted_write.skel.h" #include "bpf_qdisc_dynptr_use_after_invalidate_clone.skel.h" #define LO_IFINDEX 1
@@ -230,6 +231,7 @@ void test_ns_bpf_qdisc(void)RUN_TESTS (bpf_qdisc_fail__invalid_dynptr);RUN_TESTS (bpf_qdisc_fail__invalid_dynptr_cross_frame);RUN_TESTS (bpf_qdisc_fail__invalid_dynptr_slice); +RUN_TESTS (bpf_qdisc_fail__untrusted_write);RUN_TESTS (bpf_qdisc_dynptr_use_after_invalidate_clone); }
tools/testing/selftests/bpf/progs/bpf_qdisc_fail__untrusted_write.c new file +65 -0
65 lines not on this page · raw message
Signature · 1 line
2.43.0
This series was applied to bpf/bpf-next.git (master) by Kumar Kartikeya Dwivedi <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Kumar Kartikeya Dwivedi <[email protected]>:
Quoted 27 lines · On Mon, 17 Aug 2026 16:10:13 +0200 you wrote:
Cover the ways in which the type recorded for a shared load used to lose the
BPF_PROBE_MEMrewrite which would then trigger a NULL deref if not handled properly.# LDLIBS=-static PKG_CONFIG='pkg-config --static' ./vmtest.sh -- ./test_progs -t
mem_rdonly_untrusted[...]#242/1 mem_rdonly_untrusted/btf_id_to_ptr_mem:OK #242/2 mem_rdonly_untrusted/ldx_is_ok_bad_addr:OK #242/3 mem_rdonly_untrusted/ldx_is_ok_good_addr:OK #242/4 mem_rdonly_untrusted/offset_not_tracked:OK #242/5 mem_rdonly_untrusted/stx_not_ok:OK #242/6 mem_rdonly_untrusted/atomic_not_ok:OK #242/7 mem_rdonly_untrusted/atomic_rmw_not_ok:OK #242/8 mem_rdonly_untrusted/kfunc_param_not_ok:OK #242/9 mem_rdonly_untrusted/mixed_mem_type:OK #242/10 mem_rdonly_untrusted/mixed_mem_untrusted_btf_id_type:OK #242/11 mem_rdonly_untrusted/mixed_mem_btf_id_type:OK #242/12 mem_rdonly_untrusted/mixed_rdonly_mem_btf_id_type:OK #242/13 mem_rdonly_untrusted/mixed_mem_mem_type:OK #242/14 mem_rdonly_untrusted/mixed_map_value_mem_type:OK #242/15 mem_rdonly_untrusted/mixed_stack_mem_type:OK #242/16 mem_rdonly_untrusted/diff_size_access:OK #242/17 mem_rdonly_untrusted/misaligned_access:OK #242/18 mem_rdonly_untrusted/null_check:OK #242/19 mem_rdonly_untrusted/ldx_is_ok_commuted_addr:OK #242/20 mem_rdonly_untrusted/helper_param_not_ok:OK #242 mem_rdonly_untrusted:OK
Quoted 3 lines
Summary: 1/20 PASSED, 0 SKIPPED, 0/0 FAILED
[...]
Here is the summary with links:
- [bpf-next,v3,1/3] selftests/bpf: Add tests for pointer type merge at a shared load
https://git.kernel.org/bpf/bpf-next/c/78d8e5b375c0 - [bpf-next,v3,2/3] selftests/bpf: Add tests for fault prone loads out of RCU pointers https://git.kernel.org/bpf/bpf-next/c/2b918fe2f11f - [bpf-next,v3,3/3] selftests/bpf: Add tests for a store on a fault prone qdisc pointer https://git.kernel.org/bpf/bpf-next/c/f79066c78402
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html