bpf: Fix helper writes to read-only maps
Subsystems (9)
Daniel Borkmann
maintainerPATCH v3 1/6 bpf: Fix helper writes to read-only maps
Lonial found an issue that despite user- and BPF-side frozen BPF map (like in case of .rodata), it was still possible to write into it from a BPF program side through specific helpers having ARG_PTR_TO_{LONG,INT} as arguments.
In check_func_arg() when the argument is as mentioned, the meta->raw_mode is never set. Later, check_helper_mem_access(), under the case of PTR_TO_MAP_VALUE as register base type, it assumes BPF_READ for the subsequent call to check_map_access_type() and given the BPF map is read-only it succeeds.
The helpers really need to be annotated as ARG_PTR_TO_{LONG,INT} | MEM_UNINIT when results are written into them as opposed to read out of them. The latter indicates that it's okay to pass a pointer to uninitialized memory as the memory is written to anyway.
However, ARG_PTR_TO_{LONG,INT} is a special case of ARG_PTR_TO_FIXED_SIZE_MEM just with additional alignment requirement. So it is better to just get rid of the ARG_PTR_TO_{LONG,INT} special cases altogether and reuse the fixed size memory types. For this, add MEM_ALIGNED to additionally ensure alignment given these helpers write directly into the args via *<ptr> = val. The .arg*_size has been initialized reflecting the actual sizeof(*<ptr>). In some of the helpers these are long types, in others these are fixed integer types.
MEM_ALIGNED can only be used in combination with MEM_FIXED_SIZE annotated argument types, since in !MEM_FIXED_SIZE cases the verifier does not know the buffer size a priori and therefore cannot blindly write *<ptr> = val.
---
v1 -> v2:
- const volatile long (Andrii)
include/linux/bpf.h | 7 +++++-- kernel/bpf/helpers.c | 8 ++++++-- kernel/bpf/syscall.c | 4 +++- kernel/bpf/verifier.c | 38 +++++--------------------------------- kernel/trace/bpf_trace.c | 8 ++++++-- net/core/filter.c | 8 ++++++-- 6 files changed, 31 insertions(+), 42 deletions(-)
include/linux/bpf.h +5 -2
@@ -695,6 +695,11 @@ enum bpf_type_flag {/* DYNPTR points to xdp_buff */ DYNPTR_TYPE_XDP =BIT (16 +BPF_BASE_TYPE_BITS ), +/* Memory must be aligned on some architectures, used in combination with +* MEM_FIXED_SIZE. +*/ +MEM_ALIGNED =BIT (17 +BPF_BASE_TYPE_BITS ), + __BPF_TYPE_FLAG_MAX, __BPF_TYPE_LAST_FLAG = __BPF_TYPE_FLAG_MAX - 1, };
@@ -732,8 +737,6 @@ enum bpf_arg_type {ARG_ANYTHING ,/* any (initialized) argument is ok */ ARG_PTR_TO_SPIN_LOCK ,/* pointer to bpf_spin_lock */ ARG_PTR_TO_SOCK_COMMON ,/* pointer to sock_common */ -ARG_PTR_TO_INT ,/* pointer to int */ -ARG_PTR_TO_LONG ,/* pointer to long */ ARG_PTR_TO_SOCKET ,/* pointer to bpf_sock (fullsock) */ ARG_PTR_TO_BTF_ID ,/* pointer to in-kernel struct */ ARG_PTR_TO_RINGBUF_MEM, /* pointer to dynamically reserved ringbuf memory */
kernel/bpf/helpers.c +6 -2
@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,
@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long), }; BPF_CALL_3(bpf_strncmp, const char *, s1, u32, s1_sz, const char *, s2)
kernel/bpf/syscall.c +3 -1
@@ -5954,7 +5954,9 @@ static const struct bpf_func_proto bpf_kallsyms_lookup_name_proto = { .arg1_type = ARG_PTR_TO_MEM, .arg2_type = ARG_CONST_SIZE_OR_ZERO, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(u64), }; static const struct bpf_func_proto *
kernel/bpf/verifier.c +5 -33
@@ -8306,16 +8306,6 @@ static bool arg_type_is_dynptr(enum bpf_arg_type type)return base_type (type) ==ARG_PTR_TO_DYNPTR ; } -static int int_ptr_type_to_size (enum bpf_arg_type type) -{ -if (type ==ARG_PTR_TO_INT ) -return sizeof (u32); -else if (type ==ARG_PTR_TO_LONG ) -return sizeof (u64); - -return -EINVAL ; -} -static int resolve_map_arg_type (struct bpf_verifier_env *env,const struct bpf_call_arg_meta *meta,enum bpf_arg_type *arg_type)
@@ -8388,16 +8378,6 @@ static const struct bpf_reg_types mem_types = { }, }; -static const struct bpf_reg_types int_ptr_types = { - .types = { -PTR_TO_STACK , -PTR_TO_PACKET , -PTR_TO_PACKET_META , -PTR_TO_MAP_KEY , -PTR_TO_MAP_VALUE , - }, -}; -static const struct bpf_reg_types spin_lock_types = { .types = {PTR_TO_MAP_VALUE ,
@@ -8458,8 +8438,6 @@ static const struct bpf_reg_types *compatible_reg_types[__BPF_ARG_TYPE_MAX] = { [ARG_PTR_TO_SPIN_LOCK] = &spin_lock_types, [ARG_PTR_TO_MEM] = &mem_types, [ARG_PTR_TO_RINGBUF_MEM] = &ringbuf_mem_types, - [ARG_PTR_TO_INT] = &int_ptr_types, - [ARG_PTR_TO_LONG] = &int_ptr_types, [ARG_PTR_TO_PERCPU_BTF_ID] = &percpu_btf_ptr_types, [ARG_PTR_TO_FUNC] = &func_ptr_types, [ARG_PTR_TO_STACK] = &stack_ptr_types,
@@ -9025,6 +9003,11 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg, err =check_helper_mem_access (env, regno, fn->arg_size[arg], false, meta); +if (err) +return err; +if (arg_type &MEM_ALIGNED ) + err =check_ptr_alignment (env, reg,0 , + fn->arg_size[arg], true); }break ;case ARG_CONST_SIZE :
@@ -9049,17 +9032,6 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg,if (err)return err;break ; -case ARG_PTR_TO_INT : -case ARG_PTR_TO_LONG : - { -int size =int_ptr_type_to_size (arg_type); - - err =check_helper_mem_access (env, regno, size, false, meta); -if (err) -return err; - err =check_ptr_alignment (env, reg,0 , size, true); -break ; - }case ARG_PTR_TO_CONST_STR : { err =check_reg_const_str (env, reg, regno);
kernel/trace/bpf_trace.c +6 -2
@@ -1202,7 +1202,9 @@ static const struct bpf_func_proto bpf_get_func_arg_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_ANYTHING, - .arg3_type = ARG_PTR_TO_LONG, + .arg3_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg3_size = sizeof(u64), }; BPF_CALL_2(get_func_ret, void *, ctx, u64 *, value)
@@ -1218,7 +1220,9 @@ static const struct bpf_func_proto bpf_get_func_ret_proto = { .func = get_func_ret, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, - .arg2_type = ARG_PTR_TO_LONG, + .arg2_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg2_size = sizeof(u64), }; BPF_CALL_1(get_func_arg_cnt, void *, ctx)
net/core/filter.c +6 -2
@@ -6346,7 +6346,9 @@ static const struct bpf_func_proto bpf_skb_check_mtu_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_ANYTHING, - .arg3_type = ARG_PTR_TO_INT, + .arg3_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg3_size = sizeof(u32), .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, };
@@ -6357,7 +6359,9 @@ static const struct bpf_func_proto bpf_xdp_check_mtu_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_ANYTHING, - .arg3_type = ARG_PTR_TO_INT, + .arg3_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg3_size = sizeof(u32), .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, };
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 2/6 bpf: Improve check_raw_mode_ok test for MEM_UNINIT-tagged types
When checking malformed helper function signatures, also take other argument types into account aside from just ARG_PTR_TO_UNINIT_MEM.
This concerns (formerly) ARG_PTR_TO_{INT,LONG} given uninitialized memory can be passed there, too.
The func proto sanity check goes back to commit 435faee1aae9 ("bpf, verifier:
add ARG_PTR_TO_RAW_STACK type"), and its purpose was to detect wrong func protos which had more than just one MEM_UNINIT-tagged type as arguments.
The reason more than one is currently not supported is as we mark stack slots with STACK_MISC in check_helper_call() in case of raw mode based on meta.access_size to allow uninitialized stack memory to be passed to helpers when they just write into the buffer.
Probing for base type as well as MEM_UNINIT tagging ensures that other types do not get missed (as it used to be the case for ARG_PTR_TO_{INT,LONG}).
---
v1 -> v2:
- new patch (Shung-Hsi)
v2 -> v3:
- base_type(type) was needed also
kernel/bpf/verifier.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-)
kernel/bpf/verifier.c +11 -5
@@ -8296,6 +8296,12 @@ static bool arg_type_is_mem_size(enum bpf_arg_type type) type ==ARG_CONST_SIZE_OR_ZERO ; } +static bool arg_type_is_raw_mem (enum bpf_arg_type type) +{ +return base_type (type) ==ARG_PTR_TO_MEM && + type &MEM_UNINIT ; +} +static bool arg_type_is_release (enum bpf_arg_type type) {return type &OBJ_RELEASE ;
@@ -9348,15 +9354,15 @@ static bool check_raw_mode_ok(const struct bpf_func_proto *fn) {int count =0 ; -if (fn->arg1_type ==ARG_PTR_TO_UNINIT_MEM ) +if (arg_type_is_raw_mem (fn->arg1_type)) count++; -if (fn->arg2_type ==ARG_PTR_TO_UNINIT_MEM ) +if (arg_type_is_raw_mem (fn->arg2_type)) count++; -if (fn->arg3_type ==ARG_PTR_TO_UNINIT_MEM ) +if (arg_type_is_raw_mem (fn->arg3_type)) count++; -if (fn->arg4_type ==ARG_PTR_TO_UNINIT_MEM ) +if (arg_type_is_raw_mem (fn->arg4_type)) count++; -if (fn->arg5_type ==ARG_PTR_TO_UNINIT_MEM ) +if (arg_type_is_raw_mem (fn->arg5_type)) count++;/* We only support one arg being in raw mode at the moment,
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 3/6 bpf: Zero former ARG_PTR_TO_{LONG,INT} args in case of error
In reply to Daniel BorkmannFor all non-tracing helpers which formerly had ARG_PTR_TO_{LONG,INT} as input arguments, zero the value for the case of an error as otherwise it could leak memory. For tracing, it is not needed given CAP_PERFMON can already read all kernel memory anyway hence bpf_get_func_arg() and bpf_get_func_ret() is skipped in here.
Also, rearrange the MTU checker helpers a bit to among other nit fixes consolidate flag checks such that we only need to zero in one location with regards to malformed flag inputs.
---
v1 -> v2:
- only set *mtu_len in error path (Alexei)
kernel/bpf/helpers.c | 2 ++ kernel/bpf/syscall.c | 1 + net/core/filter.c | 35 +++++++++++++++++------------------ 3 files changed, 20 insertions(+), 18 deletions(-)
kernel/bpf/helpers.c +2 -0
@@ -523,6 +523,7 @@ BPF_CALL_4(bpf_strtol, const char *, buf, size_t, buf_len, u64, flags,long long _res;int err; + *res =0 ; err =__bpf_strtoll (buf, buf_len, flags, &_res);if (err <0 )return err;
@@ -551,6 +552,7 @@ BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,bool is_negative;int err; + *res =0 ; err =__bpf_strtoull (buf, buf_len, flags, &_res, &is_negative);if (err <0 )return err;
kernel/bpf/syscall.c +1 -0
@@ -5934,6 +5934,7 @@ static const struct bpf_func_proto bpf_sys_close_proto = { BPF_CALL_4(bpf_kallsyms_lookup_name, const char *, name, int, name_sz, int, flags, u64 *, res) { + *res =0 ;if (flags)return -EINVAL ;
net/core/filter.c +17 -18
@@ -6264,18 +6264,19 @@ BPF_CALL_5(bpf_skb_check_mtu, struct sk_buff *, skb,int skb_len, dev_len;int mtu; -if (unlikely (flags & ~(BPF_MTU_CHK_SEGS ))) -return -EINVAL ; - -if (unlikely (flags &BPF_MTU_CHK_SEGS && (len_diff || *mtu_len))) +if (unlikely ((flags & ~(BPF_MTU_CHK_SEGS )) || + (flags &BPF_MTU_CHK_SEGS && (len_diff || *mtu_len)))) { + *mtu_len =0 ;return -EINVAL ; + } dev =__dev_via_ifindex (dev, ifindex); -if (unlikely (!dev)) +if (unlikely (!dev)) { + *mtu_len =0 ;return -ENODEV ; + } mtu =READ_ONCE (dev->mtu); - dev_len = mtu + dev->hard_header_len;/* If set use *mtu_len as input, L3 as iph->tot_len (like fib_lookup) */
@@ -6286,10 +6287,10 @@ BPF_CALL_5(bpf_skb_check_mtu, struct sk_buff *, skb, ret =BPF_MTU_CHK_RET_SUCCESS ; goto out; } -/* At this point, skb->len exceed MTU, but as it include length of all -* segments, it can still be below MTU. The SKB can possibly get -* re-segmented in transmit path (see validate_xmit_skb). Thus, user -* must choose if segs are to be MTU checked. +/* At this point, skb->len exceeds MTU, but as it includes the length +* of all segments, it can still be below MTU. The skb can possibly +* get re-segmented in transmit path (see validate_xmit_skb). Thus, +* the user must choose if segments are to be MTU checked. */ if (skb_is_gso (skb)) { ret =BPF_MTU_CHK_RET_SUCCESS ;
@@ -6299,9 +6300,7 @@ BPF_CALL_5(bpf_skb_check_mtu, struct sk_buff *, skb, ret =BPF_MTU_CHK_RET_SEGS_TOOBIG ; } out: -/* BPF verifier guarantees valid pointer */ *mtu_len = mtu; -return ret; }
@@ -6314,16 +6313,18 @@ BPF_CALL_5(bpf_xdp_check_mtu, struct xdp_buff *, xdp,int mtu, dev_len;/* XDP variant doesn't support multi-buffer segment check (yet) */ -if (unlikely (flags)) +if (unlikely (flags)) { + *mtu_len =0 ;return -EINVAL ; + } dev =__dev_via_ifindex (dev, ifindex); -if (unlikely (!dev)) +if (unlikely (!dev)) { + *mtu_len =0 ;return -ENODEV ; + } mtu =READ_ONCE (dev->mtu); - -/* Add L2-header as dev MTU is L3 size */ dev_len = mtu + dev->hard_header_len;/* Use *mtu_len as input, L3 as iph->tot_len (like fib_lookup) */
@@ -6334,9 +6335,7 @@ BPF_CALL_5(bpf_xdp_check_mtu, struct xdp_buff *, xdp,if (xdp_len > dev_len) ret =BPF_MTU_CHK_RET_FRAG_NEEDED ; -/* BPF verifier guarantees valid pointer */ *mtu_len = mtu; -return ret; }
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 4/6 selftests/bpf: Fix ARG_PTR_TO_LONG {half-,}uninitialized test
In reply to Daniel BorkmannThe assumption of 'in privileged mode reads from uninitialized stack locations are permitted' is not quite correct since the verifier was probing for read access rather than write access. Both tests need to be annotated as __success for privileged and unprivileged.
--- tools/testing/selftests/bpf/progs/verifier_int_ptr.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
tools/testing/selftests/bpf/progs/verifier_int_ptr.c +1 -4
@@ -8,7 +8,6 @@ SEC("socket") __description("ARG_PTR_TO_LONG uninitialized") __success -__failure_unpriv __msg_unpriv("invalid indirect read from stack R4 off -16+0 size 8")__naked void arg_ptr_to_long_uninitialized (void ) { asm volatile (" \
@@ -36,9 +35,7 @@ __naked void arg_ptr_to_long_uninitialized(void) SEC("socket") __description("ARG_PTR_TO_LONG half-uninitialized") -/* in privileged mode reads from uninitialized stack locations are permitted */ -__success __failure_unpriv -__msg_unpriv("invalid indirect read from stack R4 off -16+4 size 8") +__success __retval(0) __naked void ptr_to_long_half_uninitialized(void) {
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 5/6 selftests/bpf: Rename ARG_PTR_TO_LONG test description
In reply to Daniel BorkmannGiven we got rid of ARG_PTR_TO_LONG, change the test case description to avoid potential confusion:
# ./vmtest.sh -- ./test_progs -t verifier_int_ptr [...] ./test_progs -t verifier_int_ptr [ 1.610563] bpf_testmod: loading out-of-tree module taints kernel. [ 1.611049] bpf_testmod: module verification failed: signature and/or required key missing - tainting kernel #489/1 verifier_int_ptr/arg pointer to long uninitialized:OK #489/2 verifier_int_ptr/arg pointer to long half-uninitialized:OK #489/3 verifier_int_ptr/arg pointer to long misaligned:OK #489/4 verifier_int_ptr/arg pointer to long size < sizeof(long):OK #489/5 verifier_int_ptr/arg pointer to long initialized:OK #489 verifier_int_ptr:OK Summary: 1/5 PASSED, 0 SKIPPED, 0 FAILED
---
v1 -> v2:
- new patch
tools/testing/selftests/bpf/progs/verifier_int_ptr.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
tools/testing/selftests/bpf/progs/verifier_int_ptr.c +5 -5
@@ -6,7 +6,7 @@#include "bpf_misc.h" SEC("socket") -__description("ARG_PTR_TO_LONG uninitialized") +__description("arg pointer to long uninitialized") __success__naked void arg_ptr_to_long_uninitialized (void ) {
@@ -34,7 +34,7 @@ __naked void arg_ptr_to_long_uninitialized(void) } SEC("socket") -__description("ARG_PTR_TO_LONG half-uninitialized") +__description("arg pointer to long half-uninitialized") __success __retval(0) __naked void ptr_to_long_half_uninitialized(void)
@@ -64,7 +64,7 @@ __naked void ptr_to_long_half_uninitialized(void) } SEC("cgroup/sysctl") -__description("ARG_PTR_TO_LONG misaligned") +__description("arg pointer to long misaligned") __failure __msg("misaligned stack access off 0+-20+0 size 8") __naked void arg_ptr_to_long_misaligned(void) {
@@ -95,7 +95,7 @@ __naked void arg_ptr_to_long_misaligned(void) } SEC("cgroup/sysctl") -__description("ARG_PTR_TO_LONG size < sizeof(long)") +__description("arg pointer to long size < sizeof(long)") __failure __msg("invalid indirect access to stack R4 off=-4 size=8") __naked void to_long_size_sizeof_long(void) {
@@ -124,7 +124,7 @@ __naked void to_long_size_sizeof_long(void) } SEC("cgroup/sysctl") -__description("ARG_PTR_TO_LONG initialized") +__description("arg pointer to long initialized") __success__naked void arg_ptr_to_long_initialized (void ) {
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH v3 6/6 selftests/bpf: Add a test case to write into .rodata
In reply to Daniel BorkmannAdd a test case which attempts to write into .rodata section of the BPF program, and for comparison this adds test cases also for .bss and .data section.
Before fix:
# ./vmtest.sh -- ./test_progs -t verifier_const [...] ./test_progs -t verifier_const tester_init:PASS:tester_log_buf 0 nsec process_subtest:PASS:obj_open_mem 0 nsec process_subtest:PASS:specs_alloc 0 nsec run_subtest:PASS:obj_open_mem 0 nsec run_subtest:FAIL:unexpected_load_success unexpected success: 0 #465/1 verifier_const/rodata: write rejected:FAIL #465/2 verifier_const/bss: write accepted:OK #465/3 verifier_const/data: write accepted:OK #465 verifier_const:FAIL [...]
After fix:
# ./vmtest.sh -- ./test_progs -t verifier_const [...] ./test_progs -t verifier_const #465/1 verifier_const/rodata: write rejected:OK #465/2 verifier_const/bss: write accepted:OK #465/3 verifier_const/data: write accepted:OK #465 verifier_const:OK [...]
---
v1 -> v2:
- const volatile long (Andrii)
.../selftests/bpf/prog_tests/verifier.c | 2 + .../selftests/bpf/progs/verifier_const.c | 42 +++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_const.c
tools/testing/selftests/bpf/prog_tests/verifier.c +2 -0
@@ -21,6 +21,7 @@#include "verifier_cgroup_inv_retcode.skel.h" #include "verifier_cgroup_skb.skel.h" #include "verifier_cgroup_storage.skel.h" +#include "verifier_const.skel.h" #include "verifier_const_or.skel.h" #include "verifier_ctx.skel.h" #include "verifier_ctx_sk_msg.skel.h"
@@ -145,6 +146,7 @@ void test_verifier_cfg(void) { RUN(verifier_cfg); }void test_verifier_cgroup_inv_retcode (void ) {RUN (verifier_cgroup_inv_retcode); }void test_verifier_cgroup_skb (void ) {RUN (verifier_cgroup_skb); }void test_verifier_cgroup_storage (void ) {RUN (verifier_cgroup_storage); } +void test_verifier_const (void ) {RUN (verifier_const); }void test_verifier_const_or (void ) {RUN (verifier_const_or); }void test_verifier_ctx (void ) {RUN (verifier_ctx); }void test_verifier_ctx_sk_msg (void ) {RUN (verifier_ctx_sk_msg); }
tools/testing/selftests/bpf/progs/verifier_const.c new file +42 -0
42 lines not on this page · raw message
Signature · 1 line
2.43.0
Quoted 16 lines · Daniel Borkmann
kernel/bpf/helpers.c +3
-1@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,
kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = { · line 574
Quoted 7 lines
kernel/bpf/helpers.c +3
-1@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type =ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long),
This is not correct.ARG_PTR_TO_LONG is bpf-side "long", not kernel side "long".
kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = {
Quoted 6 lines
kernel/bpf/helpers.c +0
-6-static int int_ptr_type_to_size (enum bpf_arg_type type) -{ -if (type ==ARG_PTR_TO_INT ) -return sizeof (u32); -else if (type ==ARG_PTR_TO_LONG ) -return sizeof (u64);
as seen here.
BPF_CALL_4(bpf_strto[u]l, ... long *, res)
are buggy.
but they call __bpf_strtoll which takes 'long long' correctly.
The fix for BPF_CALL_4(bpf_strto[u]l and uapi/bpf.h is orthogonal, but this patch shouldn't make the verifier see it as sizeof(long).
pw-bot: cr
Daniel Borkmann
maintainerQuoted 37 lines · Alexei Starovoitov
Quoted 16 lines · Daniel Borkmann
kernel/bpf/helpers.c +3
-1@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = { · line 574
Quoted 7 lines
kernel/bpf/helpers.c +3
-1@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type =ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long),This is not correct.
ARG_PTR_TO_LONGis bpf-side "long", not kernel side "long".kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = {
Quoted 6 lines
kernel/bpf/helpers.c +0
-6-static int int_ptr_type_to_size (enum bpf_arg_type type) -{ -if (type ==ARG_PTR_TO_INT ) -return sizeof (u32); -else if (type ==ARG_PTR_TO_LONG ) -return sizeof (u64);as seen here.
Quoted 2 lines
BPF_CALL_4(bpf_strto[u]l, ... long *, res)
are buggy.
Right, the int_ptr_type_to_size() checks mem based on u64 vs writing long in the helper which mismatches on 32bit archs.
Quoted 4 lines
but they call
__bpf_strtollwhich takes 'long long' correctly.The fix for BPF_CALL_4(bpf_strto[u]l and
uapi/bpf.his orthogonal, but this patch shouldn't make the verifier see it as sizeof(long).
Ok, so I'll fix the BPF_CALL signatures for the affected helpers as one more patch and also align arg*_size to {s,u}64 then so that there's no mismatch.
Thanks,
Daniel
Daniel Borkmann
maintainerQuoted 44 lines · Daniel Borkmann
Quoted 37 lines · Alexei Starovoitov
Quoted 16 lines · Daniel Borkmann
kernel/bpf/helpers.c +3
-1@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = { · line 574
Quoted 7 lines
kernel/bpf/helpers.c +3
-1@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long),This is not correct.
ARG_PTR_TO_LONGis bpf-side "long", not kernel side "long".kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = {
Quoted 6 lines
kernel/bpf/helpers.c +0
-6-static int int_ptr_type_to_size (enum bpf_arg_type type) -{ - if (type == ARG_PTR_TO_INT) - return sizeof(u32); - else if (type == ARG_PTR_TO_LONG) - return sizeof(u64);as seen here.
Quoted 2 lines
BPF_CALL_4(bpf_strto[u]l, ... long *, res)
are buggy.Right, the
int_ptr_type_to_size()checks mem based on u64 vs writing long in the helper which mismatches on 32bit archs.
Quoted 8 lines
Quoted 4 lines
but they call
__bpf_strtollwhich takes 'long long' correctly.The fix for BPF_CALL_4(bpf_strto[u]l and
uapi/bpf.his orthogonal, but this patch shouldn't make the verifier see it as sizeof(long).Ok, so I'll fix the
BPF_CALLsignatures for the affected helpers as one more patch and also align arg*_size to {s,u}64 then so that there's no mismatch.
Not fixing up BPF_CALL signatures but aligning .arg*_size to sizeof(u64) would fwiw keep things as today. This has the downside that on 32bit archs one could end up leaking out 4b of uninit mem (as verifier assumes fixed 64bit and in case of write there is no need to init the var as verifier thinks the helper will fill it all). Ugly bit is the func proto is enabled in bpf_base_func_proto() which is ofc available for unpriv (if someone actually has it turned on..).
Fixing up BPF_CALL signatures for bpf_strto{u,}l where res pointer becomes {s,u}64 and .arg*_size fixed 8b, would be nicer, but assuming this includes also the uapi helper description, then we'll also have to end up adapting selftests (given compiler warns on ptr type mismatch) :/
One option could be we fix up BPF_CALL sites, but not the uapi helper such that selftests stay as they are. For 64bit no change, but 32bit archs this will be subtle as we write beyond the passed/expected long inside the helper.
Last option is to have it like in this patch to reflect actual long in .arg*_size still no change 64bit and 32bit becomes also correct, just quirk that it's not fixed/portable size. Thoughts on the options? All ugly, but last one looked most sane to me fwiw.
Thanks,
Daniel
Daniel Borkmann
maintainerQuoted 62 lines · Daniel Borkmann
Quoted 44 lines · Daniel Borkmann
Quoted 37 lines · Alexei Starovoitov
Quoted 16 lines · Daniel Borkmann
kernel/bpf/helpers.c +3
-1@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = { · line 574
Quoted 7 lines
kernel/bpf/helpers.c +3
-1@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long),This is not correct.
ARG_PTR_TO_LONGis bpf-side "long", not kernel side "long".kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = {
Quoted 6 lines
kernel/bpf/helpers.c +0
-6-static int int_ptr_type_to_size (enum bpf_arg_type type) -{ - if (type == ARG_PTR_TO_INT) - return sizeof(u32); - else if (type == ARG_PTR_TO_LONG) - return sizeof(u64);as seen here.
Quoted 2 lines
BPF_CALL_4(bpf_strto[u]l, ... long *, res)
are buggy.Right, the
int_ptr_type_to_size()checks mem based on u64 vs writing long in the helper which mismatches on 32bit archs.Quoted 8 lines
Quoted 4 lines
but they call
__bpf_strtollwhich takes 'long long' correctly.The fix for BPF_CALL_4(bpf_strto[u]l and
uapi/bpf.his orthogonal, but this patch shouldn't make the verifier see it as sizeof(long).Ok, so I'll fix the
BPF_CALLsignatures for the affected helpers as one more patch and also align arg*_size to {s,u}64 then so that there's no mismatch.Not fixing up
BPF_CALLsignatures but aligning .arg*_size to sizeof(u64) would fwiw keep things as today. This has the downside that on 32bit archs one could end up leaking out 4b of uninit mem (as verifier assumes fixed 64bit and in case of write there is no need to init the var as verifier thinks the helper will fill it all). Ugly bit is the func proto is enabled inbpf_base_func_proto()which is ofc available for unpriv (if someone actually has it turned on..).
Quoted 8 lines
Fixing up
BPF_CALLsignatures for bpf_strto{u,}l where res pointer becomes {s,u}64 and .arg*_size fixed 8b, would be nicer, but assuming this includes also the uapi helper description, then we'll also have to end up adapting selftests (given compiler warns on ptr type mismatch) :/One option could be we fix up
BPF_CALLsites, but not the uapi helper such that selftests stay as they are. For 64bit no change, but 32bit archs this will be subtle as we write beyond the passed/expected long inside the helper.
Nevermind, scratch the incorrect last part, only this option would do the trick since from bpf pov its bpf-side "long" (as its unchanged in the uapi header which gets pulled into the prog).
Thanks,
Daniel
Quoted 69 lines · Daniel Borkmann
Quoted 67 lines · Daniel Borkmann
Quoted 44 lines · Daniel Borkmann
Quoted 37 lines · Alexei Starovoitov
Quoted 16 lines · Daniel Borkmann
kernel/bpf/helpers.c +3
-1@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = { · line 574
Quoted 7 lines
kernel/bpf/helpers.c +3
-1@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type =ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long),This is not correct.
ARG_PTR_TO_LONGis bpf-side "long", not kernel side "long".kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = {
Quoted 6 lines
kernel/bpf/helpers.c +0
-6-static int int_ptr_type_to_size (enum bpf_arg_type type) -{ -if (type ==ARG_PTR_TO_INT ) -return sizeof (u32); -else if (type ==ARG_PTR_TO_LONG ) -return sizeof (u64);as seen here.
Quoted 2 lines
BPF_CALL_4(bpf_strto[u]l, ... long *, res)
are buggy.Right, the
int_ptr_type_to_size()checks mem based on u64 vs writing long in the helper which mismatches on 32bit archs.Quoted 8 lines
Quoted 4 lines
but they call
__bpf_strtollwhich takes 'long long' correctly.The fix for BPF_CALL_4(bpf_strto[u]l and
uapi/bpf.his orthogonal, but this patch shouldn't make the verifier see it as sizeof(long).Ok, so I'll fix the
BPF_CALLsignatures for the affected helpers as one more patch and also align arg*_size to {s,u}64 then so that there's no mismatch.Not fixing up
BPF_CALLsignatures but aligning .arg*_size to sizeof(u64) would fwiw keep things as today. This has the downside that on 32bit archs one could end up leaking out 4b of uninit mem (as verifier assumes fixed 64bit and in case of write there is no need to init the var as verifier thinks the helper will fill it all). Ugly bit is the func proto is enabled inbpf_base_func_proto()which is ofc available for unpriv (if someone actually has it turned on..).Fixing up
BPF_CALLsignatures for bpf_strto{u,}l where res pointer becomes {s,u}64 and .arg*_size fixed 8b, would be nicer, but assuming this includes also the uapi helper description, then we'll also have to end up adapting selftests (given compiler warns on ptr type mismatch) :/
Quoted 7 lines
Quoted 3 lines
One option could be we fix up
BPF_CALLsites, but not the uapi helper such that selftests stay as they are. For 64bit no change, but 32bit archs this will be subtle as we write beyond the passed/expected long inside the helper.Nevermind, scratch the incorrect last part, only this option would do the trick since from bpf pov its bpf-side "long" (as its unchanged in the uapi header which gets pulled into the prog).
Right. From bpf side 'long *' is ok-sh and it's ok to stay this way in uapi/bpf.h and from there in bpf_helper_defs.h,
but BPF_CALL(bpf_strol..) needs to change.
And if we fix that we should probably change uapi/bpf.h to stay consistent. Maybe we should use 'u64 *' everywhere then?
On 32-bit archs bpf_strtol helpers were broken,
since they were converting string to 'long long', but assigning result into 32-bit 'long *',
so upper bits will be seen as uninited from bpf prog pov. This series are fixing the error path of uninit, but looks like non-error path was broken on 32-bit archs too.
Thankfully bpf_strto[u]l are the only helpers that take 'long *'. Other helpers use 'u64 *' in similar situations.
Daniel Borkmann
maintainerQuoted 77 lines · Alexei Starovoitov
Quoted 68 lines · Daniel Borkmann
Quoted 67 lines · Daniel Borkmann
Quoted 44 lines · Daniel Borkmann
Quoted 37 lines · Alexei Starovoitov
Quoted 16 lines · Daniel Borkmann
kernel/bpf/helpers.c +3
-1@@ -539,7 +539,9 @@ const struct bpf_func_proto bpf_strtol_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(long), }; BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = { · line 574
Quoted 7 lines
kernel/bpf/helpers.c +3
-1@@ -567,7 +569,9 @@ const struct bpf_func_proto bpf_strtoul_proto = { .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_LONG, + .arg4_type =ARG_PTR_TO_FIXED_SIZE_MEM | + MEM_UNINIT | MEM_ALIGNED, + .arg4_size = sizeof(unsigned long),This is not correct.
ARG_PTR_TO_LONGis bpf-side "long", not kernel side "long".kernel/bpf/helpers.c const struct bpf_func_proto bpf_strtoul_proto = {
Quoted 6 lines
kernel/bpf/helpers.c +0
-6-static int int_ptr_type_to_size (enum bpf_arg_type type) -{ -if (type ==ARG_PTR_TO_INT ) -return sizeof (u32); -else if (type ==ARG_PTR_TO_LONG ) -return sizeof (u64);as seen here.
Quoted 2 lines
BPF_CALL_4(bpf_strto[u]l, ... long *, res)
are buggy.Right, the
int_ptr_type_to_size()checks mem based on u64 vs writing long in the helper which mismatches on 32bit archs.Quoted 8 lines
Quoted 4 lines
but they call
__bpf_strtollwhich takes 'long long' correctly.The fix for BPF_CALL_4(bpf_strto[u]l and
uapi/bpf.his orthogonal, but this patch shouldn't make the verifier see it as sizeof(long).Ok, so I'll fix the
BPF_CALLsignatures for the affected helpers as one more patch and also align arg*_size to {s,u}64 then so that there's no mismatch.Not fixing up
BPF_CALLsignatures but aligning .arg*_size to sizeof(u64) would fwiw keep things as today. This has the downside that on 32bit archs one could end up leaking out 4b of uninit mem (as verifier assumes fixed 64bit and in case of write there is no need to init the var as verifier thinks the helper will fill it all). Ugly bit is the func proto is enabled inbpf_base_func_proto()which is ofc available for unpriv (if someone actually has it turned on..).Fixing up
BPF_CALLsignatures for bpf_strto{u,}l where res pointer becomes {s,u}64 and .arg*_size fixed 8b, would be nicer, but assuming this includes also the uapi helper description, then we'll also have to end up adapting selftests (given compiler warns on ptr type mismatch) :/Quoted 7 lines
Quoted 3 lines
One option could be we fix up
BPF_CALLsites, but not the uapi helper such that selftests stay as they are. For 64bit no change, but 32bit archs this will be subtle as we write beyond the passed/expected long inside the helper.Nevermind, scratch the incorrect last part, only this option would do the trick since from bpf pov its bpf-side "long" (as its unchanged in the uapi header which gets pulled into the prog).
Quoted 5 lines
Right. From bpf side 'long *' is ok-sh and it's ok to stay this way in
uapi/bpf.hand from there inbpf_helper_defs.h,
butBPF_CALL(bpf_strol..)needs to change.
And if we fix that we should probably changeuapi/bpf.hto stay consistent. Maybe we should use 'u64 *' everywhere then?
I'd love to also change uapi/bpf.h, just that this needs changes in existing BPF selftests as otherwise the build errors out e.g. on regular x86-64 with the following (without the -Werror this is 'just' a warning):
[...]
progs/verifier_const.c:28:36: error: incompatible pointer types passing 'long *' to parameter of type '__s64 *' (aka 'long long *') [-Werror,-Wincompatible-pointer-types]
28 | bpf_strtol(buff, sizeof(buff), 0, &bar);
| ^~~~[...]
One could argue that these two helpers are still fairly niche, but otoh, they've been around since 2019. :/ So I guess it's probably better to stay with the uapi/bpf.h inconsistency that they remain at {unsigned,} long instead of __{u,s}64 such that user code does not need to be adapted to the signature change.
Quoted 9 lines
On 32-bit archs
bpf_strtolhelpers were broken,
since they were converting string to 'long long', but assigning result into 32-bit 'long *',
so upper bits will be seen as uninited from bpf prog pov. This series are fixing the error path of uninit, but looks like non-error path was broken on 32-bit archs too.Thankfully bpf_strto[u]l are the only helpers that take 'long *'. Other helpers use 'u64 *' in similar situations.
Agree, thankfully just those which slipped through..