bpf: prevent r10 register from being marked as precise
Subsystems (4)
Andrii Nakryiko
maintainerPATCH 1/2 bpf: prevent r10 register from being marked as precise
r10 is a special register that is not under BPF program's control and is always effectively precise. The rest of precision logic assumes that only r0-r9 SCALAR registers are marked as precise, so prevent r10 from being marked precise.
This can happen due to signed cast instruction allowing to do something like r0 = (s8)r10;, which later, if r0 needs to be precise, would lead to an attempt to mark r10 as precise.
Prevent this with an extra check during instruction backtracking.
--- kernel/bpf/verifier.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +4 -2
@@ -3615,7 +3615,8 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx, int subseq_idx,* sreg needs precision before this insn */ bt_clear_reg (bt, dreg); -bt_set_reg (bt, sreg); +if (sreg !=BPF_REG_FP ) +bt_set_reg (bt, sreg); }else {/* dreg = K * dreg needs precision after this insn.
@@ -3631,7 +3632,8 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx, int subseq_idx,* both dreg and sreg need precision * before this insn */ -bt_set_reg (bt, sreg); +if (sreg !=BPF_REG_FP ) +bt_set_reg (bt, sreg); }/* else dreg += K * dreg still needs precision before this insn */
Signature · 1 line
2.43.0
Andrii Nakryiko
maintainerPATCH 2/2 selftests/bpf: add fp-leaking precise subprog result tests
Add selftests validating that BPF verifier handles precision marking for SCALAR registers derived from r10 (fp) register correctly.
--- .../bpf/progs/verifier_subprog_precision.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +86 -0
@@ -76,6 +76,92 @@ __naked int subprog_result_precise(void) ); } +__naked __noinline __used +static unsigned long fp_leaking_subprog() +{ + asmvolatile ( +"r0 = (s8)r10;" +"exit;" + ); +} + +__naked __noinline __used +static unsigned long sneaky_fp_leaking_subprog() +{ + asmvolatile ( +"r1 = r10;" +"r0 = (s8)r1;" +"exit;" + ); +} + +SEC("?raw_tp") +__success __log_level(2) +__msg("6: (0f) r1 += r0") +__msg("mark_precise: frame0: last_idx 6 first_idx 0 subseq_idx -1") +__msg("mark_precise: frame0: regs=r0 stack= before 5: (bf) r1 = r6") +__msg("mark_precise: frame0: regs=r0 stack= before 4: (27) r0 *= 4") +__msg("mark_precise: frame0: regs=r0 stack= before 3: (57) r0 &= 3") +__msg("mark_precise: frame0: regs=r0 stack= before 10: (95) exit") +__msg("mark_precise: frame1: regs=r0 stack= before 9: (bf) r0 = (s8)r10") +__msg("7: R0_w=scalar") +__naked int fp_precise_subprog_result (void ) +{ + asmvolatile ( +"call fp_leaking_subprog;" +/* use subprog's returned value (which is derived from r10=fp +* register), as index into vals array, forcing all of that to +* be known precisely +*/ +"r0 &= 3;" +"r0 *= 4;" +"r1 = %[vals];" +/* force precision marking */ +"r1 += r0;" +"r0 = *(u32 *)(r1 + 0);" +"exit;" + : + : __imm_ptr(vals) + : __clobber_common + ); +} + +SEC("?raw_tp") +__success __log_level(2) +__msg("6: (0f) r1 += r0") +__msg("mark_precise: frame0: last_idx 6 first_idx 0 subseq_idx -1") +__msg("mark_precise: frame0: regs=r0 stack= before 5: (bf) r1 = r6") +__msg("mark_precise: frame0: regs=r0 stack= before 4: (27) r0 *= 4") +__msg("mark_precise: frame0: regs=r0 stack= before 3: (57) r0 &= 3") +__msg("mark_precise: frame0: regs=r0 stack= before 11: (95) exit") +__msg ("mark_precise: frame1: regs=r0 stack= before 10: (bf) r0 = (s8)r1" ) +/* here r1 is marked precise, even though it's fp register, but that's fine +* because by the time we get out of subprogram it has to be derived from r10 +* anyways, at which point we'll break precision chain + */ +__msg("mark_precise: frame1: regs=r1 stack= before 9: (bf) r1 = r10") +__msg("7: R0_w=scalar") +__naked int sneaky_fp_precise_subprog_result (void ) +{ + asmvolatile ( +"call sneaky_fp_leaking_subprog;" +/* use subprog's returned value (which is derived from r10=fp +* register), as index into vals array, forcing all of that to +* be known precisely +*/ +"r0 &= 3;" +"r0 *= 4;" +"r1 = %[vals];" +/* force precision marking */ +"r1 += r0;" +"r0 = *(u32 *)(r1 + 0);" +"exit;" + : + : __imm_ptr(vals) + : __clobber_common + ); +} + SEC("?raw_tp") __success __log_level(2)__msg ("9: (0f) r1 += r0" )
Signature · 1 line
2.43.0
Re: [PATCH bpf-next 2/2] selftests/bpf: add fp-leaking precise subprog result tests
Quoted 14 lines · Andrii Nakryiko
Add selftests validating that BPF verifier handles precision marking for SCALAR registers derived from r10 (fp) register correctly.
Signed-off-by Andrii Nakryiko <[email protected]>--- .../bpf/progs/verifier_subprog_precision.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +0
-0
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c __naked int subprog_result_precise(void) · line 83
Quoted 8 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +5
-0@@ -76,6 +76,92 @@ __naked int subprog_result_precise(void) ); } +__naked __noinline __used +static unsigned long fp_leaking_subprog() +{ + asmvolatile ( + "r0 = (s8)r10;"
Our CI's clang doesn't like this instruction. I guess I'll have to encode it in binary form :(
Quoted 4 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +4
-0+"exit;" + ); +} +
[...]
Yonghong Song
reviewerRe: [PATCH bpf-next 2/2] selftests/bpf: add fp-leaking precise subprog result tests
Quoted 17 lines · Andrii Nakryiko
Quoted 16 lines · Andrii Nakryiko
Add selftests validating that BPF verifier handles precision marking for SCALAR registers derived from r10 (fp) register correctly.
Signed-off-by Andrii Nakryiko <[email protected]>--- .../bpf/progs/verifier_subprog_precision.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +0
-0@@ -76,6 +76,92 @@ __naked int subprog_result_precise(void) ); }
Quoted 7 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c __naked int subprog_result_precise(void) · line 83
Quoted 5 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +5
-0+__naked __noinline __used +static unsigned long fp_leaking_subprog() +{ + asmvolatile ( + "r0 = (s8)r10;"Our CI's clang doesn't like this instruction. I guess I'll have to encode it in binary form :(
This patch disappeared from CI so I am not able to check the result.
But I tried with the following small example.
$ cat t.c
__attribute__((naked)) unsigned long t(void)
{
asm volatile("r0 = (s8)r10;"
"exit;"
);
}$ clang --target=bpf -O2 -mcpu=v2 -g -c t.c && llvm-objdump -d t.o
t.o: file format elf64-bpf
Disassembly of section .text:
0000000000000000 <t>:
0: bf a0 08 00 00 00 00 00 r0 = (s8)r10
1: 95 00 00 00 00 00 00 00 exit-mcpu=v3/v4 has the same result.
Not sure what clang complains.
Quoted 7 lines
Quoted 5 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +4
-0+"exit;" + ); +} +[...]
Re: [PATCH bpf-next 2/2] selftests/bpf: add fp-leaking precise subprog result tests
Quoted 40 lines · Yonghong Song
Quoted 17 lines · Andrii Nakryiko
Quoted 16 lines · Andrii Nakryiko
Add selftests validating that BPF verifier handles precision marking for SCALAR registers derived from r10 (fp) register correctly.
Signed-off-by Andrii Nakryiko <[email protected]>--- .../bpf/progs/verifier_subprog_precision.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +0
-0@@ -76,6 +76,92 @@ __naked int subprog_result_precise(void) ); }Quoted 7 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c __naked int subprog_result_precise(void) · line 83
Quoted 5 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +5
-0+__naked __noinline __used +static unsigned long fp_leaking_subprog() +{ + asmvolatile ( + "r0 = (s8)r10;"Our CI's clang doesn't like this instruction. I guess I'll have to encode it in binary form :(
This patch disappeared from CI so I am not able to check the result.
But I tried with the following small example.
$ cat t.c __attribute__((naked)) unsigned long t(void) { asm volatile("r0 = (s8)r10;" "exit;" ); }
Quoted 2 lines
$ clang --target=bpf -O2 -mcpu=v2 -g -c t.c && llvm-objdump -d t.o
You are using local clang built from source code, right? I think our BPF CI still is on Clang 17 or something, so it doesn't yet understand "(s8)r10" syntax, unfortunately.
Quoted 19 lines
t.o: file format elf64-bpf
Disassembly of section .text:
0000000000000000 <t>:
0: bf a0 08 00 00 00 00 00 r0 = (s8)r10 1: 95 00 00 00 00 00 00 00 exit-mcpu=v3/v4 has the same result.
Not sure what clang complains.Quoted 7 lines
Quoted 5 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +4
-0+"exit;" + ); +} +[...]
Yonghong Song
reviewerRe: [PATCH bpf-next 2/2] selftests/bpf: add fp-leaking precise subprog result tests
Quoted 39 lines · Andrii Nakryiko
Quoted 38 lines · Yonghong Song
Quoted 17 lines · Andrii Nakryiko
Quoted 16 lines · Andrii Nakryiko
Add selftests validating that BPF verifier handles precision marking for SCALAR registers derived from r10 (fp) register correctly.
Signed-off-by Andrii Nakryiko <[email protected]>--- .../bpf/progs/verifier_subprog_precision.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +0
-0@@ -76,6 +76,92 @@ __naked int subprog_result_precise(void) ); }Quoted 7 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c __naked int subprog_result_precise(void) · line 83
Quoted 5 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +5
-0+__naked __noinline __used +static unsigned long fp_leaking_subprog() +{ + asmvolatile ( + "r0 = (s8)r10;"Our CI's clang doesn't like this instruction. I guess I'll have to encode it in binary form :(
This patch disappeared from CI so I am not able to check the result.
But I tried with the following small example.
$ cat t.c __attribute__((naked)) unsigned long t(void) { asm volatile("r0 = (s8)r10;" "exit;" ); }
Quoted 5 lines
Quoted 2 lines
$ clang --target=bpf -O2 -mcpu=v2 -g -c t.c && llvm-objdump -d t.oYou are using local clang built from source code, right? I think our BPF CI still is on Clang 17 or something, so it doesn't yet understand "(s8)r10" syntax, unfortunately.
Yes, it makes sense. Indeed in that case, either using bytes or guarding with >= llvm18 is needed.
Quoted 20 lines
Quoted 20 lines
t.o: file format elf64-bpf
Disassembly of section .text:
0000000000000000 <t>:
0: bf a0 08 00 00 00 00 00 r0 = (s8)r10 1: 95 00 00 00 00 00 00 00 exit-mcpu=v3/v4 has the same result.
Not sure what clang complains.Quoted 6 lines
Quoted 4 lines
tools/testing/selftests/bpf/progs/verifier_subprog_precision.c +4
-0+"exit;" + ); +} +[...]