bpf: verifier: fix NULL deref in map_kptr_match_type() for scalar regs
Subsystems (4)
PATCH 1/1 bpf: verifier: fix NULL deref in map_kptr_match_type() for scalar regs
A NULL pointer dereference occurs in map_kptr_match_type() when a BPF program attempts to store a scalar value (non-pointer register) into a map slot annotated as a kptr (kernel pointer).
Call chain:
check_store_reg()
-> check_mem_access()
-> check_map_kptr_access()
-> map_kptr_match_type()
-> btf_is_kernel(reg->btf) <-- NULL derefFor scalar registers reg->btf is NULL. map_kptr_match_type() passes this directly to btf_is_kernel(), which performs a container_of()-based offset access and triggers a general protection fault:
KASAN: null-ptr-deref in range [0x00000000000000e8-0x00000000000000ef] RIP: 0010:btf_is_kernel+0x2a/0x50
Fix: add an early NULL guard on reg->btf at the top of map_kptr_match_type(). If reg->btf is NULL, emit a verifier log message and return -EACCES so the program is rejected cleanly instead of crashing the kernel.
Reproducer: store a scalar into a kptr-annotated BPF_MAP_TYPE_LRU_HASH slot via a kprobe program — verifier crashes during bpf_prog_load().
--- kernel/bpf/verifier.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
kernel/bpf/verifier.c +12 -0
@@ -4545,6 +4545,18 @@ static int map_kptr_match_type(struct bpf_verifier_env *env, struct btf_field *kptr_field, struct bpf_reg_state *reg, u32 regno) { +/* +* If the source register has no BTF type (e.g. it is a scalar), +* it cannot possibly match a kptr slot. Reject early to avoid +* passing a NULL reg->btf to btf_is_kernel(), which would cause +* a NULL pointer dereference inside that function. +*/ +if (!reg->btf) { +verbose (env,"R%d is not a pointer, cannot store into kptr slot\n" , + regno); +return -EACCES ; + } +const char *targ_name =btf_type_name (kptr_field->kptr.btf, kptr_field->kptr.btf_id);int perm_flags;const char *reg_name ="" ;
Signature · 1 line
2.53.0
[email protected]
AI reviewcommit 6c1cde9635b1379ee40c94c5ecc8a7d09507c0c9 Author: Avinash Pal <[email protected]>
commit 6c1cde9635b1379ee40c94c5ecc8a7d09507c0c9
Author: Avinash Pal <[email protected]>
bpf: verifier: fix NULL deref in map_kptr_match_type() for scalar regs
A NULL pointer dereference occurs in map_kptr_match_type() when a BPF program attempts to store a scalar value (non-pointer register) into a map slot annotated as a kptr (kernel pointer).
This commit appears to fix a bug introduced in an earlier commit. Should this include a Fixes: tag?
The fix guards against NULL reg->btf before calling btf_is_kernel(), which suggests the vulnerability was introduced when map_kptr_match_type() started using btf_is_kernel() without checking if reg->btf is NULL first.
Looking at the git history, commit 61df10c7799e ("bpf: Allow storing unreferenced kptr in map") introduced map_kptr_match_type() and the call to btf_is_kernel(reg->btf) without a NULL check.
Consider adding:
---
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/24620726038
Hi Avinash,
This looks like the same bug Mykyta already addressed here:
https://lore.kernel.org/bpf/[email protected]/
That series includes both the verifier fix and a selftest for scalar store into a kptr slot, and Alexei has already picked it up.
Thanks,
[email protected]
AI reviewSashiko AI review found 2 potential issue(s): - [High] Type confusion and non-deterministic behavior by accessing union member `reg->btf` before validating register type. - [Low] Compiler warning…
Sashiko AI review found 2 potential issue(s):
- [High] Type confusion and non-deterministic behavior by accessing union member reg->btf before validating register type.
- [Low] Compiler warning due to mixed declarations and executable code.
--
commit e1d023d433c4be96ed8eba9f6b8df2ec2929d841
Author: Avinash Pal <[email protected]>
bpf: verifier: fix NULL deref in map_kptr_match_type() for scalar regs
This commit attempts to fix a NULL pointer dereference in map_kptr_match_type() by adding an early return if reg->btf is NULL. It targets a crash that occurs when storing a scalar value into a kptr slot.
Quoted 3 lines
For scalar registers
reg->btfis NULL.map_kptr_match_type()passes this directly tobtf_is_kernel(), which performs a container_of()-based offset access and triggers a general protection fault:
Since base_type(reg->type) != PTR_TO_BTF_ID evaluates to true for scalars, wouldn't the code jump to bad_type before ever reaching btf_is_kernel()?
Quoted 10 lines
kernel/bpf/verifier.c +2
-0@@ -4545,6 +4545,18 @@ static int map_kptr_match_type(struct bpf_verifier_env *env,struct btf_field *kptr_field, struct bpf_reg_state *reg, u32 regno) { +/* +* If the source register has no BTF type (e.g. it is a scalar),
kernel/bpf/verifier.c static int map_kptr_match_type(struct bpf_verifier_env *env, · line 4559
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+* it cannot possibly match a kptr slot. Reject early to avoid +* passing a NULL reg->btf to btf_is_kernel(), which would cause +* a NULL pointer dereference inside that function. +*/ +if (!reg->btf) { +verbose (env,"R%d is not a pointer, cannot store into kptr slot\n" , + regno); +return -EACCES ; + } +
Does placing this executable code before the variable declarations trigger a -Wdeclaration-after-statement compiler warning?
kernel/bpf/verifier.c static int map_kptr_match_type(struct bpf_verifier_env *env, · line 4562
Quoted 3 lines
kernel/bpf/verifier.c +0
-0const char *targ_name =btf_type_name (kptr_field->kptr.btf, kptr_field->kptr.btf_id);int perm_flags;const char *reg_name ="" ;
In struct bpf_reg_state, btf is part of a union:
struct bpf_reg_state {
...
union {
int range;
...
struct {
struct btf *btf;
u32 btf_id;
};
...
};
...
};By checking !reg->btf at the top of the function, does this read an inactive union member before validating the register type?
For instance, if the register is a PTR_TO_PACKET with range == 0, could reg->btf incorrectly evaluate to NULL here and return -EACCES instead of safely falling through to the bad_type check below?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1