bpf: Print full verification log
PATCH 1/3 bpf: Print full verification log
The log never falls within the 1024 byte limit imposed by format string buffer. So print it separately with dprintf.
--- testcases/kernel/syscalls/bpf/bpf_common.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
testcases/kernel/syscalls/bpf/bpf_common.c +6 -2
@@ -3,6 +3,8 @@* Copyright (c) 2019-2020 Linux Test Project */ +#include <stdio.h> +#define TST_NO_DEFAULT_MAIN #include "tst_test.h" #include "bpf_common.h"
@@ -118,8 +120,10 @@ int bpf_load_prog(union bpf_attr *const attr, const char *const log)if (ret !=-1 )tst_brk (TBROK ,"Invalid bpf() return value: %d" , ret); -if (log[0 ] !=0 ) -tst_brk (TBROK |TERRNO ,"Failed verification: %s" , log); +if (log[0 ] !=0 ) { +dprintf (STDERR_FILENO ,"%s\n" , log); +tst_brk (TBROK |TERRNO ,"Failed verification" ); + }tst_brk (TBROK |TERRNO ,"Failed to load program" );return ret;
Signature · 1 line
2.31.1
PATCH 2/3 bpf: Mention CAP_BPF in required privs and add fallback definition
We don't need CAP_SYS_ADMIN most of the time. bpf() can be called with only CAP_BPF even when unprivileged_bpf_disable > 0. When unprivileged_bpf_disable == 0, CAP_BPF also allows more features Vs. no privileges at all.
--- include/lapi/capability.h | 4 ++++ testcases/kernel/syscalls/bpf/bpf_common.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)
include/lapi/capability.h +4 -0
@@ -44,6 +44,10 @@# define CAP_SYS_RESOURCE 24#endif +#ifndef CAP_BPF +# define CAP_BPF 39 +#endif +#ifndef CAP_TO_INDEX # define CAP_TO_INDEX (x) ((x) >> 5)#endif
testcases/kernel/syscalls/bpf/bpf_common.c +1 -1
@@ -40,7 +40,7 @@ int bpf_map_create(union bpf_attr *const attr)if (errno ==EPERM ) {tst_res (TCONF ,"Hint: check also /proc/sys/kernel/unprivileged_bpf_disabled" );tst_brk (TCONF |TERRNO , -"bpf() requires CAP_SYS_ADMIN on this system" ); +"bpf() requires CAP_SYS_ADMIN or CAP_BPF on this system" ); }else {tst_brk (TBROK |TERRNO ,"Failed to create array map" ); }
Signature · 1 line
2.31.1
PATCH 3/3 bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
In reply to Richard PalethorpeOn older kernels pointer arithmetic requires CAP_BPF. They also lack the ability to call BPF subprogs. This makes it difficult to exploit the div/mod behavior.
Older kernels leave div/mod by zero undefined. This causes the test to fail and backporting the new behavior is difficult. So when we find that pointer arithmetic is not possible without CAP_BPF we can return TCONF. Because in this case, we know the test will fail, the risk is limited and there is little that can be done about it.
--- include/lapi/bpf.h | 1 + testcases/kernel/syscalls/bpf/bpf_prog05.c | 44 +++++++++++++++++++++- 2 files changed, 44 insertions(+), 1 deletion(-)
include/lapi/bpf.h +1 -0
@@ -27,6 +27,7 @@#define BPF_JNE 0x50/* jump != */ #define BPF_SIZE (code) ((code) & 0x18) +#define BPF_B 0x10/* 8-bit */ #define BPF_W 0x00/* 32-bit */ #define BPF_DW 0x18/* double word (64-bit) */
testcases/kernel/syscalls/bpf/bpf_prog05.c +43 -1
62 lines not on this page · raw message
Signature · 1 line
2.31.1
PATCH 1/3 bpf: Print full verification log
In reply to Richard PalethorpeHi!
Quoted 2 lines
The log never falls within the 1024 byte limit imposed by format string buffer. So print it separately with dprintf.
I guess that it would be slightly cleaner to add tst_printf() which would print the output so that we don't have to hardcode printing data into STDERR in the test like this.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v2 1/4 API: Add tst_printf to avoid specifying the output FD in tests
In bpf_common.h we have to print the verifier log with dprintf(STDERR_FILENO, ...) because it is usually too large for tst_{res,brk}(). As these functions use sprintf() and write() to allow printing in signal handlers.
We can hide the STDERR_FILENO part in the library. Just incase we want to change the fileno at some point.
---
V2: Add this patch and use tst_printf
include/tst_test.h | 3 +++ lib/tst_test.c | 9 +++++++++ 2 files changed, 12 insertions(+)
include/tst_test.h +3 -0
@@ -79,6 +79,9 @@ void tst_brk_(const char *file, const int lineno, int ttype, tst_brk_(__FILE__, __LINE__, (ttype), (arg_fmt), ##__VA_ARGS__);\ }) +void tst_printf (const char *const fmt, ...) + __attribute__((nonnull (1 ),format (printf,1 ,2 ))); +/* flush stderr and stdout */ void tst_flush (void );
lib/tst_test.c +9 -0
@@ -360,6 +360,15 @@ void tst_brk_(const char *file, const int lineno, int ttype,va_end (va); } +void tst_printf (const char *const fmt, ...) +{ +va_list va; + +va_start (va, fmt); +vdprintf (STDERR_FILENO , fmt, va); +va_end (va); +} +static void check_child_status (pid_t pid,int status) {int ret;
Signature · 1 line
2.31.1
PATCH v2 2/4 bpf: Print full verification log
The log never falls within the 1024 byte limit imposed by format string buffer. So print it separately with dprintf.
--- testcases/kernel/syscalls/bpf/bpf_common.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
testcases/kernel/syscalls/bpf/bpf_common.c +6 -2
@@ -3,6 +3,8 @@* Copyright (c) 2019-2020 Linux Test Project */ +#include <stdio.h> +#define TST_NO_DEFAULT_MAIN #include "tst_test.h" #include "bpf_common.h"
@@ -118,8 +120,10 @@ int bpf_load_prog(union bpf_attr *const attr, const char *const log)if (ret !=-1 )tst_brk (TBROK ,"Invalid bpf() return value: %d" , ret); -if (log[0 ] !=0 ) -tst_brk (TBROK |TERRNO ,"Failed verification: %s" , log); +if (log[0 ] !=0 ) { +tst_printf ("%s\n" , log); +tst_brk (TBROK |TERRNO ,"Failed verification" ); + }tst_brk (TBROK |TERRNO ,"Failed to load program" );return ret;
Signature · 1 line
2.31.1
PATCH v2 2/4 bpf: Print full verification log
Hi!
testcases/kernel/syscalls/bpf/bpf_common.c line 6
Quoted 9 lines
testcases/kernel/syscalls/bpf/bpf_common.c +1
-0@@ -3,6 +3,8 @@* Copyright (c) 2019-2020 Linux Test Project */ +#include <stdio.h>
I've removed this now unused include.
Quoted 6 lines
testcases/kernel/syscalls/bpf/bpf_common.c +0
-0#define TST_NO_DEFAULT_MAIN #include "tst_test.h" #include "bpf_common.h" @@ -118,8 +120,10 @@ int bpf_load_prog(union bpf_attr *const attr, const char *const log)if (ret !=-1 )tst_brk (TBROK ,"Invalid bpf() return value: %d" , ret);
testcases/kernel/syscalls/bpf/bpf_common.c int bpf_load_prog(union bpf_attr *const attr, const char *const log) · line 129
Quoted 10 lines
testcases/kernel/syscalls/bpf/bpf_common.c +4
-2-if (log[0 ] !=0 ) -tst_brk (TBROK |TERRNO ,"Failed verification: %s" , log); +if (log[0 ] !=0 ) { +tst_printf ("%s\n" , log); +tst_brk (TBROK |TERRNO ,"Failed verification" ); + }tst_brk (TBROK |TERRNO ,"Failed to load program" );return ret;
And pushed the whole patchset, thanks.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v2 3/4 bpf: Mention CAP_BPF in required privs and add fallback definition
In reply to Richard PalethorpeWe don't need CAP_SYS_ADMIN most of the time. bpf() can be called with only CAP_BPF even when unprivileged_bpf_disable > 0. When unprivileged_bpf_disable == 0, CAP_BPF also allows more features Vs. no privileges at all.
--- include/lapi/capability.h | 4 ++++ testcases/kernel/syscalls/bpf/bpf_common.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)
include/lapi/capability.h +4 -0
@@ -44,6 +44,10 @@# define CAP_SYS_RESOURCE 24#endif +#ifndef CAP_BPF +# define CAP_BPF 39 +#endif +#ifndef CAP_TO_INDEX # define CAP_TO_INDEX (x) ((x) >> 5)#endif
testcases/kernel/syscalls/bpf/bpf_common.c +1 -1
@@ -40,7 +40,7 @@ int bpf_map_create(union bpf_attr *const attr)if (errno ==EPERM ) {tst_res (TCONF ,"Hint: check also /proc/sys/kernel/unprivileged_bpf_disabled" );tst_brk (TCONF |TERRNO , -"bpf() requires CAP_SYS_ADMIN on this system" ); +"bpf() requires CAP_SYS_ADMIN or CAP_BPF on this system" ); }else {tst_brk (TBROK |TERRNO ,"Failed to create array map" ); }
Signature · 1 line
2.31.1
PATCH v2 4/4 bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
In reply to Richard PalethorpeOn older kernels pointer arithmetic requires CAP_BPF. They also lack the ability to call BPF subprogs. This makes it difficult to exploit the div/mod behavior.
Older kernels leave div/mod by zero undefined. This causes the test to fail and backporting the new behavior is difficult. So when we find that pointer arithmetic is not possible without CAP_BPF we can return TCONF. Because in this case, we know the test will fail, the risk is limited and there is little that can be done about it.
--- include/lapi/bpf.h | 1 + testcases/kernel/syscalls/bpf/bpf_prog05.c | 44 +++++++++++++++++++++- 2 files changed, 44 insertions(+), 1 deletion(-)
include/lapi/bpf.h +1 -0
@@ -27,6 +27,7 @@#define BPF_JNE 0x50/* jump != */ #define BPF_SIZE (code) ((code) & 0x18) +#define BPF_B 0x10/* 8-bit */ #define BPF_W 0x00/* 32-bit */ #define BPF_DW 0x18/* double word (64-bit) */
testcases/kernel/syscalls/bpf/bpf_prog05.c +43 -1
62 lines not on this page · raw message
Signature · 1 line
2.31.1
Re: [LTP] [PATCH v2 4/4] bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
Hi Richard,
Am 8/31/2021 um 11:10 AM schrieb Richard Palethorpe via ltp:
Quoted 9 lines
On older kernels pointer arithmetic requires
CAP_BPF. They also lack the ability to call BPF subprogs. This makes it difficult to exploit the div/mod behavior.Older kernels leave div/mod by zero undefined. This causes the test to fail and backporting the new behavior is difficult. So when we find that pointer arithmetic is not possible without
CAP_BPFwe can return TCONF. Because in this case, we know the test will fail, the risk is limited and there is little that can be done about it.
What does older kernel mean here?
testcases/kernel/syscalls/bpf/bpf_prog05.c static uint64_t *val; · line 100
Quoted 6 lines
testcases/kernel/syscalls/bpf/bpf_prog05.c +6
-0+ +if (ret !=-1 ) +tst_brk (TBROK ,"Invalid bpf() return value: %d" , ret); + +if (log[0 ] !=0 ) +tst_brk (TCONF |TERRNO ,"No pointer arithmetic:\n %s" , log);
This check now fails for me with the following output, where the test was successful, before this patch. The kernel is a non-standard suse 5.3.18 with realtime patches.
bpf_prog05.c:100: TCONF: No pointer arithmetic:
0: (bf) r2 = r10
1: (b7) r3 = -1
2: (0f) r2 += r3
3: (72) *(u8 *)(r2 +0) = 0
4: (b7) r0 = 0
5: (95) exit
from 2 to 3 (speculative execution): R1=ctx(id=0,off=0,imm=0) R2_w=fp0 R3_w=invP-1 R10=fp0 3: (72) *(u8 *)(r2 +0) = 0
invalid stack off=0 size=1
processed 7 insns (limit 1000000) max_states_per_insn 0 total_states 0 peak_states 0 mark_read 0 : EACCES (13)
Is this too old? But then again, the test was successful before this patch and your commit message states, that it was not successful on "older kernels".
Joerg
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v2 4/4] bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
Hello Joerg,
Quoted 13 lines · Joerg Vehlow
Hi Richard,
Am 8/31/2021 um 11:10 AM schrieb Richard Palethorpe via ltp:
Quoted 9 lines
On older kernels pointer arithmetic requires
CAP_BPF. They also lack the ability to call BPF subprogs. This makes it difficult to exploit the div/mod behavior.
Older kernels leave div/mod by zero undefined. This causes the test to
fail and backporting the new behavior is difficult. So when we find that pointer arithmetic is not possible withoutCAP_BPFwe can return TCONF. Because in this case, we know the test will fail, the risk is limited and there is little that can be done about it.
Quoted 1 line
What does older kernel mean here?
I'm refering to multiple different kernel versions (perhaps confusingly). On much older kernels we don't have any issues because pointer arithmetic was not possible in sensitive contexts.
Then it was made possible, but div/mod by zero was undefined. Then that was fixed, but IIRC there were other issues. Depending on what commits you have, any number of outcomes are possible.
Quoted 28 lines
testcases/kernel/syscalls/bpf/bpf_prog05.c static uint64_t *val; · line 100
Quoted 7 lines
testcases/kernel/syscalls/bpf/bpf_prog05.c +6
-0+ +if (ret !=-1 ) +tst_brk (TBROK ,"Invalid bpf() return value: %d" , ret); + +if (log[0 ] !=0 ) +tst_brk (TCONF |TERRNO ,"No pointer arithmetic:\n %s" , log);This check now fails for me with the following output, where the test was successful, before this patch. The kernel is a non-standard suse 5.3.18 with realtime patches.
bpf_prog05.c:100: TCONF: No pointer arithmetic:
0: (bf) r2 = r10
1: (b7) r3 = -1
2: (0f) r2 += r3
3: (72) *(u8 *)(r2 +0) = 0
4: (b7) r0 = 0
5: (95) exitfrom 2 to 3 (speculative execution): R1=ctx(id=0,off=0,imm=0) R2_w=fp0 R3_w=invP-1 R10=fp0
3: (72) *(u8 *)(r2 +0) = 0
invalid stack off=0 size=1
processed 7 insns (limit 1000000)max_states_per_insn0total_states0peak_states0mark_read0
: EACCES (13)
Quoted 3 lines
Is this too old? But then again, the test was successful before this patch and your commit message states, that it was not successful on "older kernels".
Are you testing on ARM? eBPF adopted the ARM behavior when dividing by zero.
Signature · 5 lines
Thank you, Richard. -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v2 4/4] bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
Hi Richard,
Am 1/11/2022 um 3:36 PM schrieb Richard Palethorpe:
Quoted 23 lines
Quoted 23 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ if (log[0] != 0) + tst_brk(TCONF | TERRNO, "No pointer arithmetic:\n %s", log);This check now fails for me with the following output, where the test was successful, before this patch. The kernel is a non-standard suse 5.3.18 with realtime patches.
bpf_prog05.c:100: TCONF: No pointer arithmetic:
0: (bf) r2 = r10
1: (b7) r3 = -1
2: (0f) r2 += r3
3: (72) *(u8 *)(r2 +0) = 0
4: (b7) r0 = 0
5: (95) exitfrom 2 to 3 (speculative execution): R1=ctx(id=0,off=0,imm=0) R2_w=fp0 R3_w=invP-1 R10=fp0
3: (72) *(u8 *)(r2 +0) = 0
invalid stack off=0 size=1
processed 7 insns (limit 1000000)max_states_per_insn0total_states0peak_states0mark_read0
: EACCES (13)
Quoted 7 lines
Quoted 3 lines
Is this too old? But then again, the test was successful before this patch and your commit message states, that it was not successful on "older kernels".
Are you testing on ARM? eBPF adopted the ARM behavior when dividing by zero.
No this is x86 and I was expecting 5.3 to not be "very old". IIRC patches for the bug tested here are partly already integrated into 4.19, so I guess 5.3 shouldn't be "very old" in that context?
I am not sure what you tried to test, I guess accessing the stack using indirect pointer arithmetic? Because changing the store to "*(u8 *)(r10 - 1) = 0", works. But if this indirection is required for the actually test, it should fail, but it doesn't -> I think the check tests something, that is not actually required for the actual test. I guess what you wanted to check is what BPF_MAP_ARRAY_STX does. There is one major difference between your implementation of the check and BPF_MAP_ARRAY_STX: BPF_MAP_ARRAY_STX uses an immediate value, to add to r2 compared to a register in your check:
* r2 = fp
* r2 += r2 - 4
vs
* r2 = r10
* r3 = -1
* r2 += r3
That is actually what makes the difference here...
If I modify the check like this it works:
testcases/kernel/syscalls/bpf/bpf_prog05.c +2 -4
@@ -67,13 +67,11 @@ static void ensure_ptr_arithmetic(void) {const struct bpf_insn prog_insn[] = {/* r2 = r10 -* r3 = -1 -* r2 += r3 +* r2 += -1 * *(char *)r2 = 0 */ BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), -BPF_MOV64_IMM (BPF_REG_3 ,-1 ), -BPF_ALU64_REG (BPF_ADD ,BPF_REG_2 ,BPF_REG_3 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-1 ),BPF_ST_MEM (BPF_B ,BPF_REG_2 ,0 ,0 ),/* exit(0) */
Is this still checking what it is supposed to? Then I would send it post this as a patch
Joerg
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v2 4/4] bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
Hello Joerg,
Quoted 38 lines · Joerg Vehlow
Hi Richard,
Am 1/11/2022 um 3:36 PM schrieb Richard Palethorpe:
Quoted 23 lines
Quoted 23 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ if (log[0] != 0) + tst_brk(TCONF | TERRNO, "No pointer arithmetic:\n %s", log);This check now fails for me with the following output, where the test was successful, before this patch. The kernel is a non-standard suse 5.3.18 with realtime patches.
bpf_prog05.c:100: TCONF: No pointer arithmetic:
0: (bf) r2 = r10
1: (b7) r3 = -1
2: (0f) r2 += r3
3: (72) *(u8 *)(r2 +0) = 0
4: (b7) r0 = 0
5: (95) exitfrom 2 to 3 (speculative execution): R1=ctx(id=0,off=0,imm=0) R2_w=fp0 R3_w=invP-1 R10=fp0
3: (72) *(u8 *)(r2 +0) = 0
invalid stack off=0 size=1
processed 7 insns (limit 1000000)max_states_per_insn0total_states0peak_states0mark_read0
: EACCES (13)Quoted 7 lines
Quoted 3 lines
Is this too old? But then again, the test was successful before this patch and your commit message states, that it was not successful on "older kernels".
Are you testing on ARM? eBPF adopted the ARM behavior when dividing by
zero.No this is x86 and I was expecting 5.3 to not be "very old". IIRC patches for the bug tested here are partly already integrated into 4.19, so I guess 5.3 shouldn't be "very old" in that context?
Quoted 5 lines
I am not sure what you tried to test, I guess accessing the stack using indirect pointer arithmetic? Because changing the store to "*(u8 *)(r10 - 1) = 0", works. But if this indirection is required for the actually test, it should fail, but it doesn't -> I think the check tests something, that is not actually required for the actual test.
The actual test just checks what the result of modulo and division by zero are against the 'arbitrary' values chosen by ARM/upstream (simlar to the selftests BTW). This is because there are multiple different values, which can be exploited depending on what patches are applied.
However they require different logic to detect if pointer arithmetic resulted in an OOB read or write. Note that even if you can do pointer arithmetic and it results in the wrong value being accessed. It doesn't matter if it's not OOB or if the validator blocks it because it has calculated the offset in the wrong direction. It may still be exploitable in these cases, but the test will pass.
I can't remember what the exact problems were; it got very complicated so I just checked that the results of division/modulo by zero matched upstream. This resulted in a false positive on some kernel which in theory would be vulnerable if unprivileged pointer arithmetic were possible. So I added the ptr arithmetic check to prevent the test from running on kernels like this.
This also appears to prevent the test from running on your kernel which is not vulnerable in any case. Thinking about it, this may be due to a configuration option you have set
(i.e. sys/kernel/unprivileged_bpf_disabled). Perhaps the problem is this is not mentioned in the test description or TCONF message?
IIRC We chose TCONF instead of TPASS to give a hint that we're not running the full test. You could also have a vulnerable kernel, but with unpriveleged BPF disabled by a config option. In this case the test should not return TCONF because a user could change the option and make themselves vulnerable.
Quoted 8 lines
I guess what you wanted to check is what
BPF_MAP_ARRAY_STXdoes. There is one major difference between your implementation of the check andBPF_MAP_ARRAY_STX:BPF_MAP_ARRAY_STXuses an immediate value, to add to r2 compared to a register in your check:* r2 = fp
* r2 += r2 - 4
Quoted 7 lines
vs
* r2 = r10
* r3 = -1
* r2 += r3That is actually what makes the difference here...
No, BPF_MAP_ARRAY_STX is just used to output the result of div/mod by zero and I don't think it needs testing.
Quoted 23 lines
If I modify the check like this it works:
testcases/kernel/syscalls/bpf/bpf_prog05.c +2
-4@@ -67,13 +67,11 @@ static void ensure_ptr_arithmetic(void) {const struct bpf_insn prog_insn[] = {/* r2 = r10 -* r3 = -1 -* r2 += r3 +* r2 += -1 * *(char *)r2 = 0 */ BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), -BPF_MOV64_IMM (BPF_REG_3 ,-1 ), -BPF_ALU64_REG (BPF_ADD ,BPF_REG_2 ,BPF_REG_3 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-1 ),BPF_ST_MEM (BPF_B ,BPF_REG_2 ,0 ,0 ),/* exit(0) */
Quoted 4 lines
Is this still checking what it is supposed to? Then I would send it post this as a patch
Joerg
This will reintroduce the false positive.
Signature · 5 lines
Thank you, Richard. -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v2 4/4] bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
Hi Richard,
Am 1/13/2022 um 8:48 AM schrieb Richard Palethorpe:
Quoted 73 lines
Hello Joerg,
Quoted 38 lines · Joerg Vehlow
Hi Richard,
Am 1/11/2022 um 3:36 PM schrieb Richard Palethorpe:
Quoted 23 lines
Quoted 23 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ if (log[0] != 0) + tst_brk(TCONF | TERRNO, "No pointer arithmetic:\n %s", log);This check now fails for me with the following output, where the test was successful, before this patch. The kernel is a non-standard suse 5.3.18 with realtime patches.
bpf_prog05.c:100: TCONF: No pointer arithmetic:
0: (bf) r2 = r10
1: (b7) r3 = -1
2: (0f) r2 += r3
3: (72) *(u8 *)(r2 +0) = 0
4: (b7) r0 = 0
5: (95) exitfrom 2 to 3 (speculative execution): R1=ctx(id=0,off=0,imm=0) R2_w=fp0 R3_w=invP-1 R10=fp0
3: (72) *(u8 *)(r2 +0) = 0
invalid stack off=0 size=1
processed 7 insns (limit 1000000)max_states_per_insn0total_states0peak_states0mark_read0
: EACCES (13)Quoted 7 lines
Quoted 3 lines
Is this too old? But then again, the test was successful before this patch and your commit message states, that it was not successful on "older kernels".
Are you testing on ARM? eBPF adopted the ARM behavior when dividing by
zero.No this is x86 and I was expecting 5.3 to not be "very old". IIRC patches for the bug tested here are partly already integrated into 4.19, so I guess 5.3 shouldn't be "very old" in that context?
Quoted 5 lines
I am not sure what you tried to test, I guess accessing the stack using indirect pointer arithmetic? Because changing the store to "*(u8 *)(r10 - 1) = 0", works. But if this indirection is required for the actually test, it should fail, but it doesn't -> I think the check tests something, that is not actually required for the actual test.
The actual test just checks what the result of modulo and division by zero are against the 'arbitrary' values chosen by ARM/upstream (simlar to the selftests BTW). This is because there are multiple different values, which can be exploited depending on what patches are applied.
However they require different logic to detect if pointer arithmetic resulted in an OOB read or write. Note that even if you can do pointer arithmetic and it results in the wrong value being accessed. It doesn't matter if it's not OOB or if the validator blocks it because it has calculated the offset in the wrong direction. It may still be exploitable in these cases, but the test will pass.
I can't remember what the exact problems were; it got very complicated so I just checked that the results of division/modulo by zero matched upstream. This resulted in a false positive on some kernel which in theory would be vulnerable if unprivileged pointer arithmetic were possible. So I added the ptr arithmetic check to prevent the test from running on kernels like this.
This also appears to prevent the test from running on your kernel which is not vulnerable in any case. Thinking about it, this may be due to a configuration option you have set
(i.e. sys/kernel/unprivileged_bpf_disabled). Perhaps the problem is this is not mentioned in the test description or TCONF message?
Quoted 5 lines
IIRC We chose TCONF instead of TPASS to give a hint that we're not running the full test. You could also have a vulnerable kernel, but with unpriveleged BPF disabled by a config option. In this case the test should not return TCONF because a user could change the option and make themselves vulnerable.
I was looking for kernel config options, that could modify bpf behavior and also unprivileged_bpf_disable (set to 0 for me), but nothing stood out.
Quoted 43 lines
Quoted 9 lines
I guess what you wanted to check is what
BPF_MAP_ARRAY_STXdoes. There is one major difference between your implementation of the check andBPF_MAP_ARRAY_STX:BPF_MAP_ARRAY_STXuses an immediate value, to add to r2 compared to a register in your check:* r2 = fp
* r2 += r2 - 4Quoted 7 lines
vs
* r2 = r10
* r3 = -1
* r2 += r3That is actually what makes the difference here...
No,
BPF_MAP_ARRAY_STXis just used to output the result of div/mod by zero and I don't think it needs testing.Quoted 23 lines
If I modify the check like this it works:
testcases/kernel/syscalls/bpf/bpf_prog05.c +2
-4@@ -67,13 +67,11 @@ static void ensure_ptr_arithmetic(void) {const struct bpf_insn prog_insn[] = {/* r2 = r10 -* r3 = -1 -* r2 += r3 +* r2 += -1 * *(char *)r2 = 0 */ BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), -BPF_MOV64_IMM (BPF_REG_3 ,-1 ), -BPF_ALU64_REG (BPF_ADD ,BPF_REG_2 ,BPF_REG_3 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-1 ),BPF_ST_MEM (BPF_B ,BPF_REG_2 ,0 ,0 ),/* exit(0) */
Quoted 6 lines
Quoted 4 lines
Is this still checking what it is supposed to? Then I would send it post this as a patch
Joerg
This will reintroduce the false positive.
Ok, I get that.
I did some more digging and bisecting. First I bisected the mainline kernel and found, that the commit 2c78ee898 ("bpf: Implement CAP_BPF") makes the check run successful. This is only in linux >= 5.8. But my 5.4 ubuntu kernel also successfully ran the check, so I also bisected ubuntu sources [1] and found this commit to be the fix here:2fa9ab45c ("bpf: No need to simulate speculative domain for immediates") This commit is also in the mainline kernel, but only in >= 5.13.
I guess the check you implemented now disables the test for a lot of kernels, that do not have a patch like this... I will stop here and just accept, that the test is not running successfully in my case. But still wanted to share this information.
Joerg
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v2 4/4] bpf_prog05: Drop CAP_BPF and check if ptr arithmetic is allowed
Hello Joerg,
Quoted 7 lines
I did some more digging and bisecting. First I bisected the mainline kernel and found, that the commit
2c78ee898("bpf: ImplementCAP_BPF") makes the check run successful. This is only in linux >= 5.8. But my 5.4 ubuntu kernel also successfully ran the check, so I also bisected ubuntu sources [1] and found this commit to be the fix here:2fa9ab45c("bpf: No need to simulate speculative domain for immediates") This commit is also in the mainline kernel, but only in >= 5.13.
Uffff, interesting, some of the things mentioned in this commit seem familiar. I did start working on other BPF reproducers, but gave up for the time being.
Quoted 5 lines
I guess the check you implemented now disables the test for a lot of kernels, that do not have a patch like this... I will stop here and just accept, that the test is not running successfully in my case. But still wanted to share this information.
Thanks, yes this could be useful.
Quoted 6 lines
Joerg
Signature · 5 lines
Thank you, Richard. -- Mailing list info: https://lists.linux.it/listinfo/ltp