Skip to contentSkip to conversation

bpf: verifier: fix NULL deref in map_kptr_match_type() for scalar regs

PATCH In review Avinash Pal 4 participants 4 messages Apr 19 – Apr 20

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

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 deref

For 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
index 69d75515ed..15b8f71074 100644
@@ -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
#1 lore raw
commit 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:

Fixes 61df10c7799e ("bpf: Allow storing unreferenced kptr in map")

---
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

#3 lore raw
In reply to Avinash Pal
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…

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->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:

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
index 69d75515ed3f7..15b8f71074f93 100644
@@ -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 -0
 	const 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