bpf: Fix incorrect verifier simulation around jmp32's jeq/jne
Subsystems (4)
Daniel Borkmann
maintainerPATCH 1/4 bpf: Fix incorrect verifier simulation around jmp32's jeq/jne
Kuee reported a quirk in the jmp32's jeq/jne simulation, namely that the register value does not match expectations for the fall-through path. For example:
Before fix:
0: R1=ctx(off=0,imm=0) R10=fp0
0: (b7) r2 = 0 ; R2_w=P0 1: (b7) r6 = 563 ; R6_w=P563 2: (87) r2 = -r2 ; R2_w=Pscalar() 3: (87) r2 = -r2 ; R2_w=Pscalar() 4: (4c) w2 |= w6 ; R2_w=Pscalar(umin=563,umax=4294967295,var_off=(0x233; 0xfffffdcc),s32_min=-2147483085) R6_w=P563 5: (56) if w2 != 0x8 goto pc+1 ; R2_w=P571 <--- [*]
6: (95) exit
R0 !read_ok
After fix:
0: R1=ctx(off=0,imm=0) R10=fp0
0: (b7) r2 = 0 ; R2_w=P0 1: (b7) r6 = 563 ; R6_w=P563 2: (87) r2 = -r2 ; R2_w=Pscalar() 3: (87) r2 = -r2 ; R2_w=Pscalar() 4: (4c) w2 |= w6 ; R2_w=Pscalar(umin=563,umax=4294967295,var_off=(0x233; 0xfffffdcc),s32_min=-2147483085) R6_w=P563 5: (56) if w2 != 0x8 goto pc+1 ; R2_w=P8 <--- [*]
6: (95) exit
R0 !read_ok
As can be seen on line 5 for the branch fall-through path in R2 [*] is that given condition w2 != 0x8 is false, verifier should conclude that r2 = 8 as upper 32 bit are known to be zero. However, verifier incorrectly concludes that r2 = 571 which is far off.
The problem is it only marks false{true}_reg as known in the switch for JE/NE case, but at the end of the function, it uses {false,true}_{64,32}off to update {false,true}_reg->var_off and they still hold the prior value of {false,true}_reg->var_off before it got marked as known. The subsequent __reg_combine_32_into_64() then propagates this old var_off and derives new bounds. The information between min/max bounds on {false,true}_reg from setting the register to known const combined with the {false,true}_reg->var_off based on the old information then derives wrong register data.
Fix it by detangling the BPF_JEQ/BPF_JNE cases and updating relevant {false,true}_{64,32}off tnums along with the register marking to known constant.
--- kernel/bpf/verifier.c | 41 ++++++++++++++++++++++++----------------- 1 file changed, 24 insertions(+), 17 deletions(-)
kernel/bpf/verifier.c +24 -17
@@ -9577,26 +9577,33 @@ static void reg_set_min_max(struct bpf_reg_state *true_reg,return ;switch (opcode) { +/* JEQ/JNE comparison doesn't change the register equivalence. +* +* r1 = r2; +* if (r1 == 42) goto label; +* ... +* label: // here both r1 and r2 are known to be 42. +* +* Hence when marking register as known preserve it's ID. +*/ case BPF_JEQ : +if (is_jmp32) { +__mark_reg32_known (true_reg, val32); + true_32off =tnum_subreg (true_reg->var_off); + }else { +___mark_reg_known (true_reg, val); + true_64off = true_reg->var_off; + } +break ;case BPF_JNE : - { -struct bpf_reg_state *reg = - opcode ==BPF_JEQ ? true_reg : false_reg; - -/* JEQ/JNE comparison doesn't change the register equivalence. -* r1 = r2; -* if (r1 == 42) goto label; -* ... -* label: // here both r1 and r2 are known to be 42. -* -* Hence when marking register as known preserve it's ID. -*/ -if (is_jmp32) -__mark_reg32_known (reg, val32); -else -___mark_reg_known (reg, val); +if (is_jmp32) { +__mark_reg32_known (false_reg, val32); + false_32off =tnum_subreg (false_reg->var_off); + }else { +___mark_reg_known (false_reg, val); + false_64off = false_reg->var_off; + }break ; - }case BPF_JSET :if (is_jmp32) { false_32off =tnum_and (false_32off,tnum_const (~val32));
Signature · 1 line
2.27.0
Daniel Borkmann
maintainerPATCH 2/4 bpf: Fix insufficient bounds propagation from adjust_scalar_min_max_vals
Kuee reported a corner case where the tnum becomes constant after the call to __reg_bound_offset(), but the register's bounds are not, that is, its min bounds are still not equal to the register's max bounds.
This in turn allows to leak pointers through turning a pointer register as is into an unknown scalar via adjust_ptr_min_max_vals().
Before:
func#0 @0
0: R1=ctx(off=0,imm=0,umax=0,var_off=(0x0; 0x0)) R10=fp(off=0,imm=0,umax=0,var_off=(0x0; 0x0))
0: (b7) r0 = 1 ; R0_w=scalar(imm=1,umin=1,umax=1,var_off=(0x1; 0x0)) 1: (b7) r3 = 0 ; R3_w=scalar(imm=0,umax=0,var_off=(0x0; 0x0)) 2: (87) r3 = -r3 ; R3_w=scalar() 3: (87) r3 = -r3 ; R3_w=scalar() 4: (47) r3 |= 32767 ; R3_w=scalar(smin=-9223372036854743041,umin=32767,var_off=(0x7fff; 0xffffffffffff8000),s32_min=-2147450881) 5: (75) if r3 s>= 0x0 goto pc+1 ; R3_w=scalar(umin=9223372036854808575,var_off=(0x8000000000007fff; 0x7fffffffffff8000),s32_min=-2147450881,u32_min=32767)
6: (95) exit
from 5 to 7: R0=scalar(imm=1,umin=1,umax=1,var_off=(0x1; 0x0)) R1=ctx(off=0,imm=0,umax=0,var_off=(0x0; 0x0)) R3=scalar(umin=32767,umax=9223372036854775807,var_off=(0x7fff; 0x7fffffffffff8000),s32_min=-2147450881) R10=fp(off=0,imm=0,umax=0,var_off=(0x0; 0x0))
7: (d5) if r3 s<= 0x8000 goto pc+1 ; R3=scalar(umin=32769,umax=9223372036854775807,var_off=(0x7fff; 0x7fffffffffff8000),s32_min=-2147450881,u32_min=32767)
8: (95) exit
from 7 to 9: R0=scalar(imm=1,umin=1,umax=1,var_off=(0x1; 0x0)) R1=ctx(off=0,imm=0,umax=0,var_off=(0x0; 0x0)) R3=scalar(umin=32767,umax=32768,var_off=(0x7fff; 0x8000)) R10=fp(off=0,imm=0,umax=0,var_off=(0x0; 0x0))
9: (07) r3 += -32767 ; R3_w=scalar(imm=0,umax=1,var_off=(0x0; 0x0)) <--- [*]
10: (95) exit
What can be seen here is that R3=scalar(umin=32767,umax=32768,var_off=(0x7fff; 0x8000)) after the operation R3 += -32767 results in a 'malformed' constant, that is, R3_w=scalar(imm=0,umax=1,var_off=(0x0; 0x0)). Intersecting with var_off has not been done at that point via __update_reg_bounds(), which would have improved the umax to be equal to umin.
Refactor the tnum <> min/max bounds information flow into a reg_bounds_sync() helper and use it consistently everywhere. After the fix, bounds have been corrected to R3_w=scalar(imm=0,umax=0,var_off=(0x0; 0x0)) and thus the register is regarded as a 'proper' constant scalar of 0.
After:
func#0 @0
0: R1=ctx(off=0,imm=0,umax=0,var_off=(0x0; 0x0)) R10=fp(off=0,imm=0,umax=0,var_off=(0x0; 0x0))
0: (b7) r0 = 1 ; R0_w=scalar(imm=1,umin=1,umax=1,var_off=(0x1; 0x0)) 1: (b7) r3 = 0 ; R3_w=scalar(imm=0,umax=0,var_off=(0x0; 0x0)) 2: (87) r3 = -r3 ; R3_w=scalar() 3: (87) r3 = -r3 ; R3_w=scalar() 4: (47) r3 |= 32767 ; R3_w=scalar(smin=-9223372036854743041,umin=32767,var_off=(0x7fff; 0xffffffffffff8000),s32_min=-2147450881) 5: (75) if r3 s>= 0x0 goto pc+1 ; R3_w=scalar(umin=9223372036854808575,var_off=(0x8000000000007fff; 0x7fffffffffff8000),s32_min=-2147450881,u32_min=32767)
6: (95) exit
from 5 to 7: R0=scalar(imm=1,umin=1,umax=1,var_off=(0x1; 0x0)) R1=ctx(off=0,imm=0,umax=0,var_off=(0x0; 0x0)) R3=scalar(umin=32767,umax=9223372036854775807,var_off=(0x7fff; 0x7fffffffffff8000),s32_min=-2147450881) R10=fp(off=0,imm=0,umax=0,var_off=(0x0; 0x0))
7: (d5) if r3 s<= 0x8000 goto pc+1 ; R3=scalar(umin=32769,umax=9223372036854775807,var_off=(0x7fff; 0x7fffffffffff8000),s32_min=-2147450881,u32_min=32767)
8: (95) exit
from 7 to 9: R0=scalar(imm=1,umin=1,umax=1,var_off=(0x1; 0x0)) R1=ctx(off=0,imm=0,umax=0,var_off=(0x0; 0x0)) R3=scalar(umin=32767,umax=32768,var_off=(0x7fff; 0x8000)) R10=fp(off=0,imm=0,umax=0,var_off=(0x0; 0x0))
9: (07) r3 += -32767 ; R3_w=scalar(imm=0,umax=0,var_off=(0x0; 0x0)) <--- [*]
10: (95) exit
--- kernel/bpf/verifier.c | 72 ++++++++++++++----------------------------- 1 file changed, 23 insertions(+), 49 deletions(-)
kernel/bpf/verifier.c +23 -49
@@ -1562,6 +1562,21 @@ static void __reg_bound_offset(struct bpf_reg_state *reg) reg->var_off =tnum_or (tnum_clear_subreg (var64_off), var32_off); } +static void reg_bounds_sync (struct bpf_reg_state *reg) +{ +/* We might have learned new bounds from the var_off. */ +__update_reg_bounds (reg); +/* We might have learned something about the sign bit. */ +__reg_deduce_bounds (reg); +/* We might have learned some bits from the bounds. */ +__reg_bound_offset (reg); +/* Intersecting with the old var_off might have improved our bounds +* slightly, e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc), +* then new var_off is (0; 0x7f...fc) which improves our umax. +*/ +__update_reg_bounds (reg); +} +static bool __reg32_bound_s64 (s32 a) {return a >=0 && a <=S32_MAX ;
@@ -1603,16 +1618,8 @@ static void __reg_combine_32_into_64(struct bpf_reg_state *reg)* so they do not impact tnum bounds calculation. */ __mark_reg64_unbounded (reg); -__update_reg_bounds (reg); } - -/* Intersecting with the old var_off might have improved our bounds -* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc), -* then new var_off is (0; 0x7f...fc) which improves our umax. -*/ -__reg_deduce_bounds (reg); -__reg_bound_offset (reg); -__update_reg_bounds (reg); +reg_bounds_sync (reg); }static bool __reg64_bound_s32 (s64 a)
@@ -1628,7 +1635,6 @@ static bool __reg64_bound_u32(u64 a)static void __reg_combine_64_into_32 (struct bpf_reg_state *reg) {__mark_reg32_unbounded (reg); -if (__reg64_bound_s32 (reg->smin_value) &&__reg64_bound_s32 (reg->smax_value)) { reg->s32_min_value = (s32 )reg->smin_value; reg->s32_max_value = (s32 )reg->smax_value;
@@ -1637,14 +1643,7 @@ static void __reg_combine_64_into_32(struct bpf_reg_state *reg) reg->u32_min_value = (u32 )reg->umin_value; reg->u32_max_value = (u32 )reg->umax_value; } - -/* Intersecting with the old var_off might have improved our bounds -* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc), -* then new var_off is (0; 0x7f...fc) which improves our umax. -*/ -__reg_deduce_bounds (reg); -__reg_bound_offset (reg); -__update_reg_bounds (reg); +reg_bounds_sync (reg); }/* Mark a register as having a completely unknown (scalar) value. */
@@ -6943,9 +6942,7 @@ static void do_refine_retval_range(struct bpf_reg_state *regs, int ret_type, ret_reg->s32_max_value = meta->msize_max_value; ret_reg->smin_value = -MAX_ERRNO ; ret_reg->s32_min_value = -MAX_ERRNO ; -__reg_deduce_bounds (ret_reg); -__reg_bound_offset (ret_reg); -__update_reg_bounds (ret_reg); +reg_bounds_sync (ret_reg); } static int
@@ -8202,11 +8199,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,if (!check_reg_sane_offset (env, dst_reg, ptr_reg->type))return -EINVAL ; - -__update_reg_bounds (dst_reg); -__reg_deduce_bounds (dst_reg); -__reg_bound_offset (dst_reg); - +reg_bounds_sync (dst_reg);if (sanitize_check_bounds (env, insn, dst_reg) <0 )return -EACCES ;if (sanitize_needed (opcode)) {
@@ -8944,10 +8937,7 @@ static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,/* ALU32 ops are zero extended into 64bit register */ if (alu32)zext_32_to_64 (dst_reg); - -__update_reg_bounds (dst_reg); -__reg_deduce_bounds (dst_reg); -__reg_bound_offset (dst_reg); +reg_bounds_sync (dst_reg);return 0 ; }
@@ -9136,10 +9126,7 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn) insn->dst_reg); }zext_32_to_64 (dst_reg); - -__update_reg_bounds (dst_reg); -__reg_deduce_bounds (dst_reg); -__reg_bound_offset (dst_reg); +reg_bounds_sync (dst_reg); } }else {/* case: R = imm
@@ -9742,21 +9729,8 @@ static void __reg_combine_min_max(struct bpf_reg_state *src_reg, dst_reg->smax_value); src_reg->var_off = dst_reg->var_off =tnum_intersect (src_reg->var_off, dst_reg->var_off); -/* We might have learned new bounds from the var_off. */ -__update_reg_bounds (src_reg); -__update_reg_bounds (dst_reg); -/* We might have learned something about the sign bit. */ -__reg_deduce_bounds (src_reg); -__reg_deduce_bounds (dst_reg); -/* We might have learned some bits from the bounds. */ -__reg_bound_offset (src_reg); -__reg_bound_offset (dst_reg); -/* Intersecting with the old var_off might have improved our bounds -* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc), -* then new var_off is (0; 0x7f...fc) which improves our umax. -*/ -__update_reg_bounds (src_reg); -__update_reg_bounds (dst_reg); +reg_bounds_sync (src_reg); +reg_bounds_sync (dst_reg); } static void reg_combine_min_max(struct bpf_reg_state *true_src,
Signature · 1 line
2.27.0
Daniel Borkmann
maintainerPATCH 3/4 bpf, selftests: Add verifier test case for imm=0,umin=0,umax=1 scalar
In reply to Daniel BorkmannAdd a test case to trigger the constant scalar issue which leaves the register in scalar(imm=0,umin=0,umax=1,var_off=(0x0; 0x0)) state. Make use of dead code elimination, so that we can see the verifier bailing out on unfixed kernels. For the condition, we use jle given it checks on umax bound.
Before:
# ./test_verifier 743 #743/p jump & dead code elimination FAIL Failed to load prog 'Permission denied'! R4 !read_ok verification time 11 usec stack depth 0 processed 13 insns (limit 1000000) max_states_per_insn 0 total_states 1 peak_states 1 mark_read 1 Summary: 0 PASSED, 0 SKIPPED, 1 FAILED
After:
# ./test_verifier 743 #743/p jump & dead code elimination OK Summary: 1 PASSED, 0 SKIPPED, 0 FAILED
--- tools/testing/selftests/bpf/verifier/jump.c | 22 +++++++++++++++++++++ 1 file changed, 22 insertions(+)
tools/testing/selftests/bpf/verifier/jump.c +22 -0
@@ -373,3 +373,25 @@ .result = ACCEPT, .retval = 3, }, +{ + "jump & dead code elimination", + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,1 ), +BPF_MOV64_IMM (BPF_REG_3 ,0 ), +BPF_ALU64_IMM (BPF_NEG ,BPF_REG_3 ,0 ), +BPF_ALU64_IMM (BPF_NEG ,BPF_REG_3 ,0 ), +BPF_ALU64_IMM (BPF_OR ,BPF_REG_3 ,32767 ), +BPF_JMP_IMM (BPF_JSGE ,BPF_REG_3 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_JMP_IMM (BPF_JSLE ,BPF_REG_3 ,0x8000 ,1 ), +BPF_EXIT_INSN (), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_3 ,-32767 ), +BPF_MOV64_IMM (BPF_REG_0 ,2 ), +BPF_JMP_IMM (BPF_JLE ,BPF_REG_3 ,0 ,1 ), +BPF_MOV64_REG (BPF_REG_0 ,BPF_REG_4 ), + BPF_EXIT_INSN(), + }, + .prog_type =BPF_PROG_TYPE_SCHED_CLS , + .result = ACCEPT, + .retval = 2, +},
Signature · 1 line
2.27.0
Daniel Borkmann
maintainerPATCH 4/4 bpf, selftests: Add verifier test case for jmp32's jeq/jne
In reply to Daniel BorkmannAdd a test case to trigger the verifier's incorrect conclusion in the case of jmp32's jeq/jne. Also here, make use of dead code elimination, so that we can see the verifier bailing out on unfixed kernels.
Before:
# ./test_verifier 724 #724/p jeq32/jne32: bounds checking FAIL Failed to load prog 'Permission denied'! R4 !read_ok verification time 8 usec stack depth 0 processed 8 insns (limit 1000000) max_states_per_insn 0 total_states 1 peak_states 1 mark_read 0 Summary: 0 PASSED, 0 SKIPPED, 1 FAILED
After:
# ./test_verifier 724 #724/p jeq32/jne32: bounds checking OK Summary: 1 PASSED, 0 SKIPPED, 0 FAILED
--- tools/testing/selftests/bpf/verifier/jmp32.c | 21 ++++++++++++++++++++ 1 file changed, 21 insertions(+)
tools/testing/selftests/bpf/verifier/jmp32.c +21 -0
@@ -864,3 +864,24 @@ .result = ACCEPT, .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, }, +{ + "jeq32/jne32: bounds checking", + .insns = { +BPF_MOV64_IMM (BPF_REG_6 ,563 ), +BPF_MOV64_IMM (BPF_REG_2 ,0 ), +BPF_ALU64_IMM (BPF_NEG ,BPF_REG_2 ,0 ), +BPF_ALU64_IMM (BPF_NEG ,BPF_REG_2 ,0 ), +BPF_ALU32_REG (BPF_OR ,BPF_REG_2 ,BPF_REG_6 ), +BPF_JMP32_IMM (BPF_JNE ,BPF_REG_2 ,8 ,5 ), +BPF_JMP_IMM (BPF_JSGE ,BPF_REG_2 ,500 ,2 ), +BPF_MOV64_IMM (BPF_REG_0 ,2 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_0 ,BPF_REG_4 ), +BPF_EXIT_INSN (), +BPF_MOV64_IMM (BPF_REG_0 ,1 ), + BPF_EXIT_INSN(), + }, + .prog_type =BPF_PROG_TYPE_SCHED_CLS , + .result = ACCEPT, + .retval = 1, +},
Signature · 1 line
2.27.0
This series was applied to bpf/bpf.git (master) by Andrii Nakryiko <[email protected]>:
Hello:
This series was applied to bpf/bpf.git (master)
by Andrii Nakryiko <[email protected]>:
Quoted 13 lines · On Fri, 1 Jul 2022 14:47:24 +0200 you wrote:
Kuee reported a quirk in the jmp32's jeq/jne simulation, namely that the register value does not match expectations for the fall-through path. For example:
Before fix:
0: R1=ctx(off=0,imm=0) R10=fp0
0: (b7) r2 = 0 ; R2_w=P0 1: (b7) r6 = 563 ; R6_w=P563 2: (87) r2 = -r2 ; R2_w=Pscalar() 3: (87) r2 = -r2 ; R2_w=Pscalar() 4: (4c) w2 |= w6 ; R2_w=Pscalar(umin=563,umax=4294967295,var_off=(0x233; 0xfffffdcc),s32_min=-2147483085) R6_w=P563 5: (56) if w2 != 0x8 goto pc+1 ; R2_w=P571 <--- [*]
Quoted 4 lines
6: (95) exit
R0 !read_ok[...]
Here is the summary with links:
- [bpf,1/4] bpf: Fix incorrect verifier simulation around jmp32's jeq/jne
https://git.kernel.org/bpf/bpf/c/a12ca6277eca - [bpf,2/4] bpf: Fix insufficient bounds propagation from adjust_scalar_min_max_vals https://git.kernel.org/bpf/bpf/c/3844d153a41a - [bpf,3/4] bpf, selftests: Add verifier test case for imm=0,umin=0,umax=1 scalar https://git.kernel.org/bpf/bpf/c/73c4936f916d - [bpf,4/4] bpf, selftests: Add verifier test case for jmp32's jeq/jne https://git.kernel.org/bpf/bpf/c/a49b8ce7306c
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html