bpf: mark registers as safe or unknown in all frames
Subsystems (6)
v2 cover bpf: mark registers as safe or unknown in all frames
In case of a null check on a pointer inside a subprog, we should mark all registers with this pointer as either safe or unknown, in both the current and previous frames. Currently, only spilled registers and registers in the current frame are marked. This first patch also marks registers in previous frames.
A good reproducer looks as follow:
1: ptr = bpf_map_lookup_elem(map, &key);
2: ret = subprog(ptr) {
3: return ptr != NULL;
4: }
5: if (ret)
6: value = *ptr;
With the above, the verifier will complain on line 6 because it sees ptr as map_value_or_null despite the null check in subprog 1. The second patch implements the above as a new test case.
Note that this patch fixes another resulting bug when using bpf_sk_release():
1: sk = bpf_sk_lookup_tcp(...);
2: subprog(sk) {
3: if (sk)
4: bpf_sk_release(sk);
5: }
6: if (!sk)
7: return 0;
8: return 1;
In the above, mark_ptr_or_null_regs will warn on line 6 because it will try to free the reference state, even though it was already freed on line 3.
Changelogs:
Changes in v2:
- Fix example codes in commit message.
Paul Chaignon (2):
bpf: mark registers as safe or unknown in all frames selftests/bpf: test case for pointer null check in subprog
kernel/bpf/verifier.c | 6 ++--- tools/testing/selftests/bpf/verifier/calls.c | 25 ++++++++++++++++++++ 2 files changed, 28 insertions(+), 3 deletions(-)
Signature · 1 line
2.17.1
PATCH v2 1/2 bpf: mark registers as safe or unknown in all frames
In case of a null check on a pointer inside a subprog, we should mark all registers with this pointer as either safe or unknown, in both the current and previous frames. Currently, only spilled registers and registers in the current frame are marked. This patch also marks registers in previous frames.
A good reproducer looks as follow:
1: ptr = bpf_map_lookup_elem(map, &key);
2: ret = subprog(ptr) {
3: return ptr != NULL;
4: }
5: if (ret)
6: value = *ptr;
With the above, the verifier will complain on line 6 because it sees ptr as map_value_or_null despite the null check in subprog 1.
Note that this patch fixes another resulting bug when using bpf_sk_release():
1: sk = bpf_sk_lookup_tcp(...);
2: subprog(sk) {
3: if (sk)
4: bpf_sk_release(sk);
5: }
6: if (!sk)
7: return 0;
8: return 1;
In the above, mark_ptr_or_null_regs will warn on line 6 because it will try to free the reference state, even though it was already freed on line 3.
--- kernel/bpf/verifier.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
kernel/bpf/verifier.c +3 -3
@@ -4876,11 +4876,11 @@ static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno,*/ WARN_ON_ONCE (release_reference_state (state, id)); -for (i =0 ; i <MAX_BPF_REG ; i++) -mark_ptr_or_null_reg (state, ®s[i], id, is_null); -for (j =0 ; j <= vstate->curframe; j++) { state = vstate->frame[j]; +for (i =0 ; i <MAX_BPF_REG ; i++) +mark_ptr_or_null_reg (state, &state->regs[i], id, + is_null);bpf_for_each_spilled_reg (i, state, reg) {if (!reg)continue ;
Signature · 1 line
2.17.1
Daniel Borkmann
maintainerQuoted 46 lines · Paul Chaignon
In case of a null check on a pointer inside a subprog, we should mark all registers with this pointer as either safe or unknown, in both the current and previous frames. Currently, only spilled registers and registers in the current frame are marked. This patch also marks registers in previous frames.
A good reproducer looks as follow:
1: ptr =
bpf_map_lookup_elem(map, &key);
2: ret = subprog(ptr) {
3: return ptr != NULL;
4: }
5: if (ret)
6: value = *ptr;With the above, the verifier will complain on line 6 because it sees ptr as
map_value_or_nulldespite the null check in subprog 1.Note that this patch fixes another resulting bug when using
bpf_sk_release():1: sk =
bpf_sk_lookup_tcp(...);
2: subprog(sk) {
3: if (sk)
4:bpf_sk_release(sk);
5: }
6: if (!sk)
7: return 0;
8: return 1;In the above,
mark_ptr_or_null_regswill warn on line 6 because it will try to free the reference state, even though it was already freed on line 3.Fixes f4d7e40a5b71 ("bpf: introduce function calls (verification)")Signed-off-by Paul Chaignon <[email protected]>--- kernel/bpf/verifier.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)kernel/bpf/verifier.c +0
-0@@ -4876,11 +4876,11 @@ static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno,*/
kernel/bpf/verifier.c static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno, · line 4883
Quoted 10 lines
kernel/bpf/verifier.c +3
-3WARN_ON_ONCE (release_reference_state (state, id)); -for (i =0 ; i <MAX_BPF_REG ; i++) -mark_ptr_or_null_reg (state, ®s[i], id, is_null); -for (j =0 ; j <= vstate->curframe; j++) { state = vstate->frame[j]; +for (i =0 ; i <MAX_BPF_REG ; i++) +mark_ptr_or_null_reg (state, &state->regs[i], id, + is_null);
Small nit: I think it would be good to follow practice from clear_all_pkt_pointers() and release_reg_references() to move handling of a singe frame into its own function.
kernel/bpf/verifier.c static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno, · line 4886
Quoted 4 lines
kernel/bpf/verifier.c +0
-0bpf_for_each_spilled_reg (i, state, reg) {if (!reg)continue ;
What about semantics in other, similar functions like find_good_pkt_pointers()? Should this also consider all frames instead?
Thanks,
Daniel
Quoted 49 lines · Daniel Borkmann
Quoted 48 lines · Paul Chaignon
In case of a null check on a pointer inside a subprog, we should mark all registers with this pointer as either safe or unknown, in both the current and previous frames. Currently, only spilled registers and registers in the current frame are marked. This patch also marks registers in previous frames.
A good reproducer looks as follow:
1: ptr =
bpf_map_lookup_elem(map, &key);
2: ret = subprog(ptr) {
3: return ptr != NULL;
4: }
5: if (ret)
6: value = *ptr;With the above, the verifier will complain on line 6 because it sees ptr as
map_value_or_nulldespite the null check in subprog 1.Note that this patch fixes another resulting bug when using
bpf_sk_release():1: sk =
bpf_sk_lookup_tcp(...);
2: subprog(sk) {
3: if (sk)
4:bpf_sk_release(sk);
5: }
6: if (!sk)
7: return 0;
8: return 1;In the above,
mark_ptr_or_null_regswill warn on line 6 because it will try to free the reference state, even though it was already freed on line 3.Fixes f4d7e40a5b71 ("bpf: introduce function calls (verification)")Signed-off-by Paul Chaignon <[email protected]>--- kernel/bpf/verifier.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)kernel/bpf/verifier.c +0
-0@@ -4876,11 +4876,11 @@ static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno,*/ WARN_ON_ONCE (release_reference_state (state, id));
Quoted 11 lines
kernel/bpf/verifier.c static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno, · line 4883
Quoted 8 lines
kernel/bpf/verifier.c +3
-3-for (i =0 ; i <MAX_BPF_REG ; i++) -mark_ptr_or_null_reg (state, ®s[i], id, is_null); -for (j =0 ; j <= vstate->curframe; j++) { state = vstate->frame[j]; +for (i =0 ; i <MAX_BPF_REG ; i++) +mark_ptr_or_null_reg (state, &state->regs[i], id, + is_null);Small nit: I think it would be good to follow practice from
clear_all_pkt_pointers()andrelease_reg_references()to move handling of a singe frame into its own function.
Will do.
Quoted 8 lines
kernel/bpf/verifier.c static void mark_ptr_or_null_regs(struct bpf_verifier_state *vstate, u32 regno, · line 4886
Quoted 5 lines
kernel/bpf/verifier.c +0
-0bpf_for_each_spilled_reg (i, state, reg) {if (!reg)continue ;What about semantics in other, similar functions like
find_good_pkt_pointers()? Should this also consider all frames instead?
Looks like the same is needed in find_good_pkt_pointers(). It's the only similar function I could find though. Did you have others in mind?
I'll add a second test case for the find_good_pkt_pointers() change in v3.
Quoted 3 lines
Thanks,
Daniel
PATCH v2 2/2 selftests/bpf: test case for pointer null check in subprog
In reply to Paul ChaignonThis test case is equivalent to the following pseudo-code. It checks that the verifier does not complain on line 6 and recognizes that ptr isn't null.
1: ptr = bpf_map_lookup_elem(map, &key);
2: ret = subprog(ptr) {
3: return ptr != NULL;
4: }
5: if (ret)
6: value = *ptr;
--- tools/testing/selftests/bpf/verifier/calls.c | 25 ++++++++++++++++++++ 1 file changed, 25 insertions(+)
tools/testing/selftests/bpf/verifier/calls.c +25 -0
@@ -374,6 +374,31 @@ .prog_type = BPF_PROG_TYPE_XDP, .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, }, +{ + "calls: ptr null check in subprog", + .insns = { +BPF_ST_MEM (BPF_DW ,BPF_REG_10 ,-8 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-8 ), +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +BPF_EMIT_CALL (BPF_FUNC_map_lookup_elem), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,1 ,0 ,3 ), +BPF_JMP_IMM (BPF_JEQ ,BPF_REG_0 ,0 ,1 ), +BPF_LDX_MEM (BPF_B ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_EXIT_INSN (), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_JMP_IMM (BPF_JEQ ,BPF_REG_1 ,0 ,1 ), +BPF_MOV64_IMM (BPF_REG_0 ,1 ), + BPF_EXIT_INSN(), + }, + .errstr_unpriv ="function calls to other bpf functions are allowed for root only" , + .fixup_map_hash_48b = { 3 }, + .result_unpriv = REJECT, + .result = ACCEPT, + .retval = 0, +}, {"calls: two calls with args" , .insns = {
Signature · 1 line
2.17.1
Quoted 39 lines · Paul Chaignon
In case of a null check on a pointer inside a subprog, we should mark all registers with this pointer as either safe or unknown, in both the current and previous frames. Currently, only spilled registers and registers in the current frame are marked. This first patch also marks registers in previous frames.
A good reproducer looks as follow:
1: ptr =
bpf_map_lookup_elem(map, &key);
2: ret = subprog(ptr) {
3: return ptr != NULL;
4: }
5: if (ret)
6: value = *ptr;With the above, the verifier will complain on line 6 because it sees ptr as
map_value_or_nulldespite the null check in subprog 1. The second patch implements the above as a new test case.Note that this patch fixes another resulting bug when using
bpf_sk_release():1: sk =
bpf_sk_lookup_tcp(...);
2: subprog(sk) {
3: if (sk)
4:bpf_sk_release(sk);
5: }
6: if (!sk)
7: return 0;
8: return 1;In the above,
mark_ptr_or_null_regswill warn on line 6 because it will try to free the reference state, even though it was already freed on line 3.Changelogs:
Changes in v2:
- Fix example codes in commit message.
Quoted 7 lines
Paul Chaignon (2):
bpf: mark registers as safe or unknown in all frames selftests/bpf: test case for pointer null check in subprogkernel/bpf/verifier.c | 6 ++--- tools/testing/selftests/bpf/verifier/calls.c | 25 ++++++++++++++++++++ 2 files changed, 28 insertions(+), 3 deletions(-)
For the series: