Fix bpf mem read/write vulnerability.
cover Fix bpf mem read/write vulnerability.
Hi Greg,
Please cherry-pick this patch series into 5.15.y stable. It includes a feature that fixes CVE-2022-0500 which allows a user with cap_bpf privileges to get root privileges. The patch that fixes the bug is
patch 7/10: bpf: Make per_cpu_ptr return rdonly
The rest are the depedences required by the fix patch. Note that v5.10 and below are not affected by this bug.
This patchset has been merged in mainline v5.17 and backported to v5.16[1], except patch 10/10 ("bpf: Fix crash due to out of bounds access into reg2btf_ids."), which fixes an out-of-bound access in the main feature in this series and hasn't been backported to v5.16 yet. If it's convenient, could you apply patch 10/10 to 5.16? I can send a separate patch for v5.16, if you prefer.
Tested by compile, build and run through the bpf selftest test_progs.
[1] https://www.spinics.net/lists/stable/msg535877.html
Hao Luo (9):
bpf: Introduce composable reg, ret and arg types.
bpf: Replace ARG_XXX_OR_NULL with ARG_XXX | PTR_MAYBE_NULL
bpf: Replace RET_XXX_OR_NULL with RET_XXX | PTR_MAYBE_NULL
bpf: Replace PTR_TO_XXX_OR_NULL with PTR_TO_XXX | PTR_MAYBE_NULL
bpf: Introduce MEM_RDONLY flag
bpf: Convert PTR_TO_MEM_OR_NULL to composable types.
bpf: Make per_cpu_ptr return rdonly PTR_TO_MEM.
bpf: Add MEM_RDONLY for helper args that are pointers to rdonly mem. bpf/selftests: Test PTR_TO_RDONLY_MEM
Kumar Kartikeya Dwivedi (1):
bpf: Fix crash due to out of bounds access into reg2btf_ids.
include/linux/bpf.h | 101 +++- include/linux/bpf_verifier.h | 18 + kernel/bpf/btf.c | 16 +- kernel/bpf/cgroup.c | 2 +- kernel/bpf/helpers.c | 12 +- kernel/bpf/map_iter.c | 4 +- kernel/bpf/ringbuf.c | 2 +- kernel/bpf/syscall.c | 2 +- kernel/bpf/verifier.c | 488 +++++++++--------- kernel/trace/bpf_trace.c | 22 +- net/core/bpf_sk_storage.c | 2 +- net/core/filter.c | 64 +-- net/core/sock_map.c | 2 +- .../selftests/bpf/prog_tests/ksyms_btf.c | 14 + .../bpf/progs/test_ksyms_btf_write_check.c | 29 ++ 15 files changed, 445 insertions(+), 333 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_btf_write_check.c
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 1/10 bpf: Introduce composable reg, ret and arg types.
commit d639b9d13a39cf15639cbe6e8b2c43eb60148a73 upstream.
There are some common properties shared between bpf reg, ret and arg values. For instance, a value may be a NULL pointer, or a pointer to a read-only memory. Previously, to express these properties, enumeration was used. For example, in order to test whether a reg value can be NULL, reg_type_may_be_null() simply enumerates all types that are possibly NULL. The problem of this approach is that it's not scalable and causes a lot of duplication. These properties can be combined, for example, a type could be either MAYBE_NULL or RDONLY, or both.
This patch series rewrites the layout of reg_type, arg_type and ret_type, so that common properties can be extracted and represented as composable flag. For example, one can write
ARG_PTR_TO_MEM | PTR_MAYBE_NULL
which is equivalent to the previous
ARG_PTR_TO_MEM_OR_NULL
The type ARG_PTR_TO_MEM are called "base type" in this patch. Base types can be extended with flags. A flag occupies the higher bits while base types sits in the lower bits.
This patch in particular sets up a set of macro for this purpose. The following patches will rewrite arg_types, ret_types and reg_types respectively.
--- include/linux/bpf.h | 42 ++++++++++++++++++++++++++++++++++++ include/linux/bpf_verifier.h | 14 ++++++++++++ 2 files changed, 56 insertions(+)
include/linux/bpf.h +42 -0
@@ -293,6 +293,29 @@ bool bpf_map_meta_equal(const struct bpf_map *meta0,extern const struct bpf_map_ops bpf_map_offload_ops; +/* bpf_type_flag contains a set of flags that are applicable to the values of +* arg_type, ret_type and reg_type. For example, a pointer value may be null, +* or a memory is read-only. We classify types into two categories: base types +* and extended types. Extended types are base types combined with a type flag. +* +* Currently there are no more than 32 base types in arg_type, ret_type and +* reg_types. +*/ +#define BPF_BASE_TYPE_BITS 8 + +enum bpf_type_flag { +/* PTR may be NULL. */ +PTR_MAYBE_NULL =BIT (0 +BPF_BASE_TYPE_BITS ), + + __BPF_TYPE_LAST_FLAG =PTR_MAYBE_NULL , +}; + +/* Max number of base types. */ +#define BPF_BASE_TYPE_LIMIT (1UL << BPF_BASE_TYPE_BITS) + +/* Max number of all types. */ +#define BPF_TYPE_LIMIT (__BPF_TYPE_LAST_FLAG | (__BPF_TYPE_LAST_FLAG - 1)) +/* function argument constraints */ enum bpf_arg_type {ARG_DONTCARE =0 ,/* unused argument in helper function */
@@ -339,7 +362,13 @@ enum bpf_arg_type {ARG_PTR_TO_CONST_STR ,/* pointer to a null terminated read-only string */ ARG_PTR_TO_TIMER ,/* pointer to bpf_timer */ __BPF_ARG_TYPE_MAX, + +/* This must be the last entry. Its purpose is to ensure the enum is +* wide enough to hold the higher bits reserved for bpf_type_flag. +*/ + __BPF_ARG_TYPE_LIMIT =BPF_TYPE_LIMIT , }; +static_assert (__BPF_ARG_TYPE_MAX <=BPF_BASE_TYPE_LIMIT );/* type of values returned from helper functions */ enum bpf_return_type {
@@ -355,7 +384,14 @@ enum bpf_return_type {RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL ,/* returns a pointer to a valid memory or a btf_id or NULL */ RET_PTR_TO_MEM_OR_BTF_ID ,/* returns a pointer to a valid memory or a btf_id */ RET_PTR_TO_BTF_ID ,/* returns a pointer to a btf_id */ + __BPF_RET_TYPE_MAX, + +/* This must be the last entry. Its purpose is to ensure the enum is +* wide enough to hold the higher bits reserved for bpf_type_flag. +*/ + __BPF_RET_TYPE_LIMIT =BPF_TYPE_LIMIT , }; +static_assert (__BPF_RET_TYPE_MAX <=BPF_BASE_TYPE_LIMIT );/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs * to in-kernel helper functions and for adjusting imm32 field in BPF_CALL
@@ -457,7 +493,13 @@ enum bpf_reg_type {PTR_TO_FUNC ,/* reg points to a bpf program function */ PTR_TO_MAP_KEY ,/* reg points to a map element key */ __BPF_REG_TYPE_MAX, + +/* This must be the last entry. Its purpose is to ensure the enum is +* wide enough to hold the higher bits reserved for bpf_type_flag. +*/ + __BPF_REG_TYPE_LIMIT =BPF_TYPE_LIMIT , }; +static_assert (__BPF_REG_TYPE_MAX <=BPF_BASE_TYPE_LIMIT );/* The information passed from prog-specific *_is_valid_access * back to the verifier.
include/linux/bpf_verifier.h +14 -0
@@ -535,4 +535,18 @@ int bpf_check_attach_target(struct bpf_verifier_log *log,u32 btf_id, struct bpf_attach_target_info *tgt_info); +#define BPF_BASE_TYPE_MASK GENMASK(BPF_BASE_TYPE_BITS - 1, 0) + +/* extract base type from bpf_{arg, return, reg}_type. */ +static inline u32 base_type (u32 type) +{ +return type &BPF_BASE_TYPE_MASK ; +} + +/* extract flags from an extended type. See bpf_type_flag in bpf.h. */ +static inline u32 type_flag (u32 type) +{ +return type & ~BPF_BASE_TYPE_MASK ; +} +#endif /* _LINUX_BPF_VERIFIER_H */
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 2/10 bpf: Replace ARG_XXX_OR_NULL with ARG_XXX | PTR_MAYBE_NULL
In reply to Hao Luocommit 48946bd6a5d695c50b34546864b79c1f910a33c1 upstream.
We have introduced a new type to make bpf_arg composable, by reserving high bits of bpf_arg to represent flags of a type.
One of the flags is PTR_MAYBE_NULL which indicates a pointer may be NULL. When applying this flag to an arg_type, it means the arg can take NULL pointer. This patch switches the qualified arg_types to use this flag. The arg_types changed in this patch include:
1. ARG_PTR_TO_MAP_VALUE_OR_NULL
2. ARG_PTR_TO_MEM_OR_NULL
3. ARG_PTR_TO_CTX_OR_NULL
4. ARG_PTR_TO_SOCKET_OR_NULL
5. ARG_PTR_TO_ALLOC_MEM_OR_NULL
6. ARG_PTR_TO_STACK_OR_NULL
This patch does not eliminate the use of these arg_types, instead it makes them an alias to the 'ARG_XXX | PTR_MAYBE_NULL'.
--- include/linux/bpf.h | 15 +++++++++------ kernel/bpf/verifier.c | 39 ++++++++++++++------------------------- 2 files changed, 23 insertions(+), 31 deletions(-)
include/linux/bpf.h +9 -6
@@ -327,13 +327,11 @@ enum bpf_arg_type {ARG_PTR_TO_MAP_KEY ,/* pointer to stack used as map key */ ARG_PTR_TO_MAP_VALUE ,/* pointer to stack used as map value */ ARG_PTR_TO_UNINIT_MAP_VALUE ,/* pointer to valid memory used to store a map value */ -ARG_PTR_TO_MAP_VALUE_OR_NULL ,/* pointer to stack used as map value or NULL */ /* the following constraints used to prototype bpf_memcmp() and other * functions that access data on eBPF program stack */ ARG_PTR_TO_MEM ,/* pointer to valid memory (stack, packet, map value) */ -ARG_PTR_TO_MEM_OR_NULL ,/* pointer to valid memory or NULL */ ARG_PTR_TO_UNINIT_MEM ,/* pointer to memory does not need to be initialized, * helper function must fill all bytes or clear * them in error case.
@@ -343,26 +341,31 @@ enum bpf_arg_type {ARG_CONST_SIZE_OR_ZERO ,/* number of bytes accessed from memory or 0 */ ARG_PTR_TO_CTX ,/* pointer to context */ -ARG_PTR_TO_CTX_OR_NULL ,/* pointer to context or NULL */ 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_SOCKET_OR_NULL ,/* pointer to bpf_sock (fullsock) or NULL */ ARG_PTR_TO_BTF_ID ,/* pointer to in-kernel struct */ ARG_PTR_TO_ALLOC_MEM ,/* pointer to dynamically allocated memory */ -ARG_PTR_TO_ALLOC_MEM_OR_NULL ,/* pointer to dynamically allocated memory or NULL */ ARG_CONST_ALLOC_SIZE_OR_ZERO ,/* number of allocated bytes requested */ ARG_PTR_TO_BTF_ID_SOCK_COMMON ,/* pointer to in-kernel sock_common or bpf-mirrored bpf_sock */ ARG_PTR_TO_PERCPU_BTF_ID ,/* pointer to in-kernel percpu type */ ARG_PTR_TO_FUNC ,/* pointer to a bpf program function */ -ARG_PTR_TO_STACK_OR_NULL ,/* pointer to stack or NULL */ +ARG_PTR_TO_STACK ,/* pointer to stack */ ARG_PTR_TO_CONST_STR ,/* pointer to a null terminated read-only string */ ARG_PTR_TO_TIMER ,/* pointer to bpf_timer */ __BPF_ARG_TYPE_MAX, +/* Extended arg_types. */ +ARG_PTR_TO_MAP_VALUE_OR_NULL =PTR_MAYBE_NULL |ARG_PTR_TO_MAP_VALUE , +ARG_PTR_TO_MEM_OR_NULL =PTR_MAYBE_NULL |ARG_PTR_TO_MEM , +ARG_PTR_TO_CTX_OR_NULL =PTR_MAYBE_NULL |ARG_PTR_TO_CTX , +ARG_PTR_TO_SOCKET_OR_NULL =PTR_MAYBE_NULL |ARG_PTR_TO_SOCKET , +ARG_PTR_TO_ALLOC_MEM_OR_NULL =PTR_MAYBE_NULL |ARG_PTR_TO_ALLOC_MEM , +ARG_PTR_TO_STACK_OR_NULL =PTR_MAYBE_NULL |ARG_PTR_TO_STACK , +/* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag. */
kernel/bpf/verifier.c +14 -25
@@ -478,14 +478,9 @@ static bool arg_type_may_be_refcounted(enum bpf_arg_type type)return type ==ARG_PTR_TO_SOCK_COMMON ; } -static bool arg_type_may_be_null (enum bpf_arg_type type) +static bool type_may_be_null (u32 type) { -return type ==ARG_PTR_TO_MAP_VALUE_OR_NULL || - type ==ARG_PTR_TO_MEM_OR_NULL || - type ==ARG_PTR_TO_CTX_OR_NULL || - type ==ARG_PTR_TO_SOCKET_OR_NULL || - type ==ARG_PTR_TO_ALLOC_MEM_OR_NULL || - type ==ARG_PTR_TO_STACK_OR_NULL ; +return type &PTR_MAYBE_NULL ; }/* Determine whether the function releases some resources allocated by another
@@ -4796,9 +4791,8 @@ static int process_timer_func(struct bpf_verifier_env *env, int regno,static bool arg_type_is_mem_ptr (enum bpf_arg_type type) { -return type ==ARG_PTR_TO_MEM || - type ==ARG_PTR_TO_MEM_OR_NULL || - type ==ARG_PTR_TO_UNINIT_MEM ; +return base_type (type) ==ARG_PTR_TO_MEM || +base_type (type) ==ARG_PTR_TO_UNINIT_MEM ; }static bool arg_type_is_mem_size (enum bpf_arg_type type)
@@ -4932,31 +4926,26 @@ static const struct bpf_reg_types *compatible_reg_types[__BPF_ARG_TYPE_MAX] = { [ARG_PTR_TO_MAP_KEY] = &map_key_value_types, [ARG_PTR_TO_MAP_VALUE] = &map_key_value_types, [ARG_PTR_TO_UNINIT_MAP_VALUE] = &map_key_value_types, - [ARG_PTR_TO_MAP_VALUE_OR_NULL] = &map_key_value_types, [ARG_CONST_SIZE] = &scalar_types, [ARG_CONST_SIZE_OR_ZERO] = &scalar_types, [ARG_CONST_ALLOC_SIZE_OR_ZERO] = &scalar_types, [ARG_CONST_MAP_PTR] = &const_map_ptr_types, [ARG_PTR_TO_CTX] = &context_types, - [ARG_PTR_TO_CTX_OR_NULL] = &context_types, [ARG_PTR_TO_SOCK_COMMON ] = &sock_types, #ifdef CONFIG_NET [ARG_PTR_TO_BTF_ID_SOCK_COMMON ] = &btf_id_sock_common_types, #endif [ARG_PTR_TO_SOCKET] = &fullsock_types, - [ARG_PTR_TO_SOCKET_OR_NULL] = &fullsock_types, [ARG_PTR_TO_BTF_ID] = &btf_ptr_types, [ARG_PTR_TO_SPIN_LOCK] = &spin_lock_types, [ARG_PTR_TO_MEM] = &mem_types, - [ARG_PTR_TO_MEM_OR_NULL] = &mem_types, [ARG_PTR_TO_UNINIT_MEM] = &mem_types, [ARG_PTR_TO_ALLOC_MEM] = &alloc_mem_types, - [ARG_PTR_TO_ALLOC_MEM_OR_NULL] = &alloc_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_OR_NULL] = &stack_ptr_types, + [ARG_PTR_TO_STACK] = &stack_ptr_types, [ARG_PTR_TO_CONST_STR] = &const_str_ptr_types, [ARG_PTR_TO_TIMER] = &timer_types, };
@@ -4970,7 +4959,7 @@ static int check_reg_type(struct bpf_verifier_env *env, u32 regno,const struct bpf_reg_types *compatible;int i, j; - compatible = compatible_reg_types[arg_type]; + compatible = compatible_reg_types[base_type (arg_type)];if (!compatible) {verbose (env,"verifier internal error: unsupported arg type %d\n" , arg_type);return -EFAULT ;
@@ -5051,15 +5040,14 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg,return -EACCES ; } -if (arg_type ==ARG_PTR_TO_MAP_VALUE || - arg_type ==ARG_PTR_TO_UNINIT_MAP_VALUE || - arg_type ==ARG_PTR_TO_MAP_VALUE_OR_NULL ) { +if (base_type (arg_type) ==ARG_PTR_TO_MAP_VALUE || +base_type (arg_type) ==ARG_PTR_TO_UNINIT_MAP_VALUE ) { err =resolve_map_arg_type (env, meta, &arg_type);if (err)return err; } -if (register_is_null (reg) &&arg_type_may_be_null (arg_type)) +if (register_is_null (reg) &&type_may_be_null (arg_type))/* A NULL register has a SCALAR_VALUE type, so skip * type checking. */
@@ -5128,10 +5116,11 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg, err =check_helper_mem_access (env, regno, meta->map_ptr->key_size, false,NULL ); - }else if (arg_type ==ARG_PTR_TO_MAP_VALUE || - (arg_type ==ARG_PTR_TO_MAP_VALUE_OR_NULL && - !register_is_null (reg)) || - arg_type ==ARG_PTR_TO_UNINIT_MAP_VALUE ) { + }else if (base_type (arg_type) ==ARG_PTR_TO_MAP_VALUE || +base_type (arg_type) ==ARG_PTR_TO_UNINIT_MAP_VALUE ) { +if (type_may_be_null (arg_type) &®ister_is_null (reg)) +return 0 ; +/* bpf_map_xxx(..., map_ptr, ..., value) call: * check [value, value + map->value_size) validity */
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 3/10 bpf: Replace RET_XXX_OR_NULL with RET_XXX | PTR_MAYBE_NULL
In reply to Hao Luocommit 3c4807322660d4290ac9062c034aed6b87243861 upstream.
We have introduced a new type to make bpf_ret composable, by reserving high bits to represent flags.
One of the flag is PTR_MAYBE_NULL, which indicates a pointer may be NULL. When applying this flag to ret_types, it means the returned value could be a NULL pointer. This patch switches the qualified arg_types to use this flag. The ret_types changed in this patch include:
1. RET_PTR_TO_MAP_VALUE_OR_NULL
2. RET_PTR_TO_SOCKET_OR_NULL
3. RET_PTR_TO_TCP_SOCK_OR_NULL
4. RET_PTR_TO_SOCK_COMMON_OR_NULL
5. RET_PTR_TO_ALLOC_MEM_OR_NULL
6. RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL
7. RET_PTR_TO_BTF_ID_OR_NULL
This patch doesn't eliminate the use of these names, instead it makes them aliases to 'RET_PTR_TO_XXX | PTR_MAYBE_NULL'.
--- include/linux/bpf.h | 19 ++++++++++------ kernel/bpf/helpers.c | 2 +- kernel/bpf/verifier.c | 52 +++++++++++++++++++++---------------------- 3 files changed, 39 insertions(+), 34 deletions(-)
include/linux/bpf.h +12 -7
@@ -378,17 +378,22 @@ enum bpf_return_type {RET_INTEGER ,/* function returns integer */ RET_VOID ,/* function doesn't return anything */ RET_PTR_TO_MAP_VALUE ,/* returns a pointer to map elem value */ -RET_PTR_TO_MAP_VALUE_OR_NULL ,/* returns a pointer to map elem value or NULL */ -RET_PTR_TO_SOCKET_OR_NULL ,/* returns a pointer to a socket or NULL */ -RET_PTR_TO_TCP_SOCK_OR_NULL ,/* returns a pointer to a tcp_sock or NULL */ -RET_PTR_TO_SOCK_COMMON_OR_NULL ,/* returns a pointer to a sock_common or NULL */ -RET_PTR_TO_ALLOC_MEM_OR_NULL ,/* returns a pointer to dynamically allocated memory or NULL */ -RET_PTR_TO_BTF_ID_OR_NULL ,/* returns a pointer to a btf_id or NULL */ -RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL ,/* returns a pointer to a valid memory or a btf_id or NULL */ +RET_PTR_TO_SOCKET ,/* returns a pointer to a socket */ +RET_PTR_TO_TCP_SOCK ,/* returns a pointer to a tcp_sock */ +RET_PTR_TO_SOCK_COMMON ,/* returns a pointer to a sock_common */ +RET_PTR_TO_ALLOC_MEM ,/* returns a pointer to dynamically allocated memory */ RET_PTR_TO_MEM_OR_BTF_ID ,/* returns a pointer to a valid memory or a btf_id */ RET_PTR_TO_BTF_ID ,/* returns a pointer to a btf_id */ __BPF_RET_TYPE_MAX, +/* Extended ret_types. */ +RET_PTR_TO_MAP_VALUE_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_MAP_VALUE , +RET_PTR_TO_SOCKET_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_SOCKET , +RET_PTR_TO_TCP_SOCK_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_TCP_SOCK , +RET_PTR_TO_SOCK_COMMON_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_SOCK_COMMON , +RET_PTR_TO_ALLOC_MEM_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_ALLOC_MEM , +RET_PTR_TO_BTF_ID_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_BTF_ID , +/* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag. */
kernel/bpf/helpers.c +1 -1
@@ -667,7 +667,7 @@ BPF_CALL_2(bpf_per_cpu_ptr, const void *, ptr, u32, cpu)const struct bpf_func_proto bpf_per_cpu_ptr_proto = { .func = bpf_per_cpu_ptr, .gpl_only = false, - .ret_type =RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL , + .ret_type =RET_PTR_TO_MEM_OR_BTF_ID |PTR_MAYBE_NULL , .arg1_type =ARG_PTR_TO_PERCPU_BTF_ID , .arg2_type =ARG_ANYTHING , };
kernel/bpf/verifier.c +26 -26
109 lines not on this page · raw message
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 4/10 bpf: Replace PTR_TO_XXX_OR_NULL with PTR_TO_XXX | PTR_MAYBE_NULL
In reply to Hao Luocommit c25b2ae136039ffa820c26138ed4a5e5f3ab3841 upstream.
We have introduced a new type to make bpf_reg composable, by allocating bits in the type to represent flags.
One of the flags is PTR_MAYBE_NULL which indicates a pointer may be NULL. This patch switches the qualified reg_types to use this flag. The reg_types changed in this patch include:
1. PTR_TO_MAP_VALUE_OR_NULL
2. PTR_TO_SOCKET_OR_NULL
3. PTR_TO_SOCK_COMMON_OR_NULL
4. PTR_TO_TCP_SOCK_OR_NULL
5. PTR_TO_BTF_ID_OR_NULL
6. PTR_TO_MEM_OR_NULL
7. PTR_TO_RDONLY_BUF_OR_NULL
8. PTR_TO_RDWR_BUF_OR_NULL
[haoluo: backport notes
There was a reg_type_may_be_null() in adjust_ptr_min_max_vals() in 5.15.x, but didn't exist in the upstream commit. This backport converted that reg_type_may_be_null() to type_may_be_null() as well.]
--- include/linux/bpf.h | 18 +-- include/linux/bpf_verifier.h | 4 + kernel/bpf/btf.c | 7 +- kernel/bpf/map_iter.c | 4 +- kernel/bpf/verifier.c | 297 +++++++++++++++-------------------- net/core/bpf_sk_storage.c | 2 +- net/core/sock_map.c | 2 +- 7 files changed, 148 insertions(+), 186 deletions(-)
include/linux/bpf.h +9 -9
@@ -461,18 +461,15 @@ enum bpf_reg_type {PTR_TO_CTX ,/* reg points to bpf_context */ CONST_PTR_TO_MAP ,/* reg points to struct bpf_map */ PTR_TO_MAP_VALUE ,/* reg points to map element value */ -PTR_TO_MAP_VALUE_OR_NULL ,/* points to map elem value or NULL */ +PTR_TO_MAP_KEY ,/* reg points to a map element key */ PTR_TO_STACK ,/* reg == frame_pointer + offset */ PTR_TO_PACKET_META ,/* skb->data - meta_len */ PTR_TO_PACKET ,/* reg points to skb->data */ PTR_TO_PACKET_END ,/* skb->data + headlen */ PTR_TO_FLOW_KEYS ,/* reg points to bpf_flow_keys */ PTR_TO_SOCKET ,/* reg points to struct bpf_sock */ -PTR_TO_SOCKET_OR_NULL ,/* reg points to struct bpf_sock or NULL */ PTR_TO_SOCK_COMMON ,/* reg points to sock_common */ -PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ -PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ PTR_TO_TP_BUFFER ,/* reg points to a writable raw tp's buffer */ PTR_TO_XDP_SOCK ,/* reg points to struct xdp_sock */ /* PTR_TO_BTF_ID points to a kernel struct that does not need
@@ -490,18 +487,21 @@ enum bpf_reg_type {* been checked for null. Used primarily to inform the verifier * an explicit null check is required for this struct. */ -PTR_TO_BTF_ID_OR_NULL ,PTR_TO_MEM ,/* reg points to valid memory region */ -PTR_TO_MEM_OR_NULL ,/* reg points to valid memory region or NULL */ PTR_TO_RDONLY_BUF ,/* reg points to a readonly buffer */ -PTR_TO_RDONLY_BUF_OR_NULL ,/* reg points to a readonly buffer or NULL */ PTR_TO_RDWR_BUF ,/* reg points to a read/write buffer */ -PTR_TO_RDWR_BUF_OR_NULL ,/* reg points to a read/write buffer or NULL */ PTR_TO_PERCPU_BTF_ID ,/* reg points to a percpu kernel variable */ PTR_TO_FUNC ,/* reg points to a bpf program function */ -PTR_TO_MAP_KEY ,/* reg points to a map element key */ __BPF_REG_TYPE_MAX, +/* Extended reg_types. */ +PTR_TO_MAP_VALUE_OR_NULL =PTR_MAYBE_NULL |PTR_TO_MAP_VALUE , +PTR_TO_SOCKET_OR_NULL =PTR_MAYBE_NULL |PTR_TO_SOCKET , +PTR_TO_SOCK_COMMON_OR_NULL =PTR_MAYBE_NULL |PTR_TO_SOCK_COMMON , +PTR_TO_TCP_SOCK_OR_NULL =PTR_MAYBE_NULL |PTR_TO_TCP_SOCK , +PTR_TO_BTF_ID_OR_NULL =PTR_MAYBE_NULL |PTR_TO_BTF_ID , +PTR_TO_MEM_OR_NULL =PTR_MAYBE_NULL |PTR_TO_MEM , +/* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag. */
include/linux/bpf_verifier.h +4 -0
@@ -18,6 +18,8 @@* that converting umax_value to int cannot overflow. */ #define BPF_MAX_VAR_SIZ (1 << 29) +/* size of type_str_buf in bpf_verifier. */ +#define TYPE_STR_BUF_LEN 64/* Liveness marks, used for registers and spilled-regs (in stack slots). * Read marks propagate upwards until they find a write mark; they record that
@@ -474,6 +476,8 @@ struct bpf_verifier_env {/* longest register parentage chain walked for liveness marking */ u32 longest_mark_read_walk;bpfptr_t fd_array; +/* buffer used in reg_type_str() to generate reg_type string */ +char type_str_buf[TYPE_STR_BUF_LEN ]; }; __printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log,
kernel/bpf/btf.c +5 -2
@@ -4800,10 +4800,13 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,/* check for PTR_TO_RDONLY_BUF_OR_NULL or PTR_TO_RDWR_BUF_OR_NULL */ for (i =0 ; i < prog->aux->ctx_arg_info_size; i++) {const struct bpf_ctx_arg_aux *ctx_arg_info = &prog->aux->ctx_arg_info[i]; +u32 type, flag; + type =base_type (ctx_arg_info->reg_type); + flag =type_flag (ctx_arg_info->reg_type);if (ctx_arg_info->offset == off && - (ctx_arg_info->reg_type ==PTR_TO_RDONLY_BUF_OR_NULL || - ctx_arg_info->reg_type ==PTR_TO_RDWR_BUF_OR_NULL )) { + (type ==PTR_TO_RDWR_BUF || type ==PTR_TO_RDONLY_BUF ) && + (flag &PTR_MAYBE_NULL )) { info->reg_type = ctx_arg_info->reg_type;return true; }
kernel/bpf/map_iter.c +2 -2
@@ -174,9 +174,9 @@ static const struct bpf_iter_reg bpf_map_elem_reg_info = { .ctx_arg_info_size = 2, .ctx_arg_info = { { offsetof(struct bpf_iter__bpf_map_elem, key), - PTR_TO_RDONLY_BUF_OR_NULL }, + PTR_TO_RDONLY_BUF | PTR_MAYBE_NULL }, { offsetof(struct bpf_iter__bpf_map_elem, value), - PTR_TO_RDWR_BUF_OR_NULL }, + PTR_TO_RDWR_BUF | PTR_MAYBE_NULL }, }, };
kernel/bpf/verifier.c +126 -171
604 lines not on this page · raw message
net/core/bpf_sk_storage.c +1 -1
@@ -929,7 +929,7 @@ static struct bpf_iter_reg bpf_sk_storage_map_reg_info = { { offsetof(struct bpf_iter__bpf_sk_storage_map , sk), PTR_TO_BTF_ID_OR_NULL }, { offsetof(struct bpf_iter__bpf_sk_storage_map, value), - PTR_TO_RDWR_BUF_OR_NULL }, + PTR_TO_RDWR_BUF | PTR_MAYBE_NULL }, }, .seq_info = &iter_seq_info, };
net/core/sock_map.c +1 -1
@@ -1575,7 +1575,7 @@ static struct bpf_iter_reg sock_map_iter_reg = { .ctx_arg_info_size = 2, .ctx_arg_info = { { offsetof(struct bpf_iter__sockmap, key), - PTR_TO_RDONLY_BUF_OR_NULL }, + PTR_TO_RDONLY_BUF | PTR_MAYBE_NULL }, { offsetof(struct bpf_iter__sockmap, sk), PTR_TO_BTF_ID_OR_NULL }, },
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 5/10 bpf: Introduce MEM_RDONLY flag
In reply to Hao Luocommit 20b2aff4bc15bda809f994761d5719827d66c0b4 upstream.
This patch introduce a flag MEM_RDONLY to tag a reg value pointing to read-only memory. It makes the following changes:
1. PTR_TO_RDWR_BUF -> PTR_TO_BUF
2. PTR_TO_RDONLY_BUF -> PTR_TO_BUF | MEM_RDONLY
--- include/linux/bpf.h | 8 ++-- kernel/bpf/btf.c | 3 +- kernel/bpf/map_iter.c | 4 +- kernel/bpf/verifier.c | 84 +++++++++++++++++++++++---------------- net/core/bpf_sk_storage.c | 2 +- net/core/sock_map.c | 2 +- 6 files changed, 60 insertions(+), 43 deletions(-)
include/linux/bpf.h +5 -3
@@ -307,7 +307,10 @@ enum bpf_type_flag {/* PTR may be NULL. */ PTR_MAYBE_NULL =BIT (0 +BPF_BASE_TYPE_BITS ), - __BPF_TYPE_LAST_FLAG = PTR_MAYBE_NULL, +/* MEM is read-only. */ +MEM_RDONLY =BIT (1 +BPF_BASE_TYPE_BITS ), + + __BPF_TYPE_LAST_FLAG = MEM_RDONLY, };/* Max number of base types. */
@@ -488,8 +491,7 @@ enum bpf_reg_type {* an explicit null check is required for this struct. */ PTR_TO_MEM ,/* reg points to valid memory region */ -PTR_TO_RDONLY_BUF ,/* reg points to a readonly buffer */ -PTR_TO_RDWR_BUF ,/* reg points to a read/write buffer */ +PTR_TO_BUF ,/* reg points to a read/write buffer */ PTR_TO_PERCPU_BTF_ID ,/* reg points to a percpu kernel variable */ PTR_TO_FUNC ,/* reg points to a bpf program function */ __BPF_REG_TYPE_MAX,
kernel/bpf/btf.c +1 -2
@@ -4804,8 +4804,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, type =base_type (ctx_arg_info->reg_type); flag =type_flag (ctx_arg_info->reg_type); -if (ctx_arg_info->offset == off && - (type ==PTR_TO_RDWR_BUF || type ==PTR_TO_RDONLY_BUF ) && +if (ctx_arg_info->offset == off && type ==PTR_TO_BUF && (flag &PTR_MAYBE_NULL )) { info->reg_type = ctx_arg_info->reg_type;return true;
kernel/bpf/map_iter.c +2 -2
@@ -174,9 +174,9 @@ static const struct bpf_iter_reg bpf_map_elem_reg_info = { .ctx_arg_info_size = 2, .ctx_arg_info = { { offsetof(struct bpf_iter__bpf_map_elem, key), - PTR_TO_RDONLY_BUF | PTR_MAYBE_NULL }, + PTR_TO_BUF | PTR_MAYBE_NULL | MEM_RDONLY }, { offsetof(struct bpf_iter__bpf_map_elem, value), - PTR_TO_RDWR_BUF | PTR_MAYBE_NULL }, + PTR_TO_BUF | PTR_MAYBE_NULL }, }, };
kernel/bpf/verifier.c +50 -34
143 lines not on this page · raw message
net/core/bpf_sk_storage.c +1 -1
@@ -929,7 +929,7 @@ static struct bpf_iter_reg bpf_sk_storage_map_reg_info = { { offsetof(struct bpf_iter__bpf_sk_storage_map , sk), PTR_TO_BTF_ID_OR_NULL }, { offsetof(struct bpf_iter__bpf_sk_storage_map, value), - PTR_TO_RDWR_BUF | PTR_MAYBE_NULL }, + PTR_TO_BUF | PTR_MAYBE_NULL }, }, .seq_info = &iter_seq_info, };
net/core/sock_map.c +1 -1
@@ -1575,7 +1575,7 @@ static struct bpf_iter_reg sock_map_iter_reg = { .ctx_arg_info_size = 2, .ctx_arg_info = { { offsetof(struct bpf_iter__sockmap, key), - PTR_TO_RDONLY_BUF | PTR_MAYBE_NULL }, + PTR_TO_BUF | PTR_MAYBE_NULL | MEM_RDONLY }, { offsetof(struct bpf_iter__sockmap, sk), PTR_TO_BTF_ID_OR_NULL }, },
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 6/10 bpf: Convert PTR_TO_MEM_OR_NULL to composable types.
In reply to Hao Luocommit cf9f2f8d62eca810afbd1ee6cc0800202b000e57 upstream.
Remove PTR_TO_MEM_OR_NULL and replace it with PTR_TO_MEM combined with flag PTR_MAYBE_NULL.
--- include/linux/bpf.h | 1 - kernel/bpf/btf.c | 2 +- kernel/bpf/verifier.c | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-)
include/linux/bpf.h +0 -1
@@ -502,7 +502,6 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL =PTR_MAYBE_NULL |PTR_TO_SOCK_COMMON ,PTR_TO_TCP_SOCK_OR_NULL =PTR_MAYBE_NULL |PTR_TO_TCP_SOCK , PTR_TO_BTF_ID_OR_NULL = PTR_MAYBE_NULL | PTR_TO_BTF_ID, -PTR_TO_MEM_OR_NULL =PTR_MAYBE_NULL |PTR_TO_MEM ,/* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag.
kernel/bpf/btf.c +1 -1
@@ -5719,7 +5719,7 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog,return -EINVAL ; } - reg->type =PTR_TO_MEM_OR_NULL ; + reg->type =PTR_TO_MEM |PTR_MAYBE_NULL ; reg->id = ++env->id_gen;continue ;
kernel/bpf/verifier.c +1 -1
@@ -13135,7 +13135,7 @@ static int do_check_common(struct bpf_verifier_env *env, int subprog)mark_reg_known_zero (env, regs, i); else if (regs[i].type == SCALAR_VALUE) mark_reg_unknown(env, regs, i); - else if (regs[i].type == PTR_TO_MEM_OR_NULL) { + else if (base_type(regs[i].type) == PTR_TO_MEM) {const u32 mem_size = regs[i].mem_size;mark_reg_known_zero (env, regs, i);
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 7/10 bpf: Make per_cpu_ptr return rdonly PTR_TO_MEM.
In reply to Hao Luocommit 34d3a78c681e8e7844b43d1a2f4671a04249c821 upstream.
Tag the return type of {per, this}_cpu_ptr with RDONLY_MEM. The returned value of this pair of helpers is kernel object, which can not be updated by bpf programs. Previously these two helpers return PTR_OT_MEM for kernel objects of scalar type, which allows one to directly modify the memory. Now with RDONLY_MEM tagging, the verifier will reject programs that write into RDONLY_MEM.
--- kernel/bpf/helpers.c | 4 ++-- kernel/bpf/verifier.c | 30 ++++++++++++++++++++++++++---- 2 files changed, 28 insertions(+), 6 deletions(-)
kernel/bpf/helpers.c +2 -2
@@ -667,7 +667,7 @@ BPF_CALL_2(bpf_per_cpu_ptr, const void *, ptr, u32, cpu)const struct bpf_func_proto bpf_per_cpu_ptr_proto = { .func = bpf_per_cpu_ptr, .gpl_only = false, - .ret_type =RET_PTR_TO_MEM_OR_BTF_ID |PTR_MAYBE_NULL , + .ret_type =RET_PTR_TO_MEM_OR_BTF_ID |PTR_MAYBE_NULL |MEM_RDONLY , .arg1_type =ARG_PTR_TO_PERCPU_BTF_ID , .arg2_type =ARG_ANYTHING , };
@@ -680,7 +680,7 @@ BPF_CALL_1(bpf_this_cpu_ptr, const void *, percpu_ptr)const struct bpf_func_proto bpf_this_cpu_ptr_proto = { .func = bpf_this_cpu_ptr, .gpl_only = false, - .ret_type =RET_PTR_TO_MEM_OR_BTF_ID , + .ret_type =RET_PTR_TO_MEM_OR_BTF_ID |MEM_RDONLY , .arg1_type =ARG_PTR_TO_PERCPU_BTF_ID , };
kernel/bpf/verifier.c +26 -4
@@ -4166,15 +4166,30 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regnmark_reg_unknown (env, regs, value_regno); } } - }else if (reg->type ==PTR_TO_MEM ) { + }else if (base_type (reg->type) ==PTR_TO_MEM ) { +bool rdonly_mem =type_is_rdonly_mem (reg->type); + +if (type_may_be_null (reg->type)) { +verbose (env,"R%d invalid mem access '%s'\n" , regno, +reg_type_str (env, reg->type)); +return -EACCES ; + } + +if (t ==BPF_WRITE && rdonly_mem) { +verbose (env,"R%d cannot write into %s\n" , + regno,reg_type_str (env, reg->type)); +return -EACCES ; + } +if (t ==BPF_WRITE && value_regno >=0 &&is_pointer_value (env, value_regno)) {verbose (env,"R%d leaks addr into mem\n" , value_regno);return -EACCES ; } + err =check_mem_region_access (env, regno, off, size, reg->mem_size, false); -if (!err && t ==BPF_READ && value_regno >=0 ) +if (!err && value_regno >=0 && (t ==BPF_READ || rdonly_mem))mark_reg_unknown (env, regs, value_regno); }else if (reg->type ==PTR_TO_CTX ) {enum bpf_reg_type reg_type =SCALAR_VALUE ;
@@ -6370,6 +6385,13 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn regs[BPF_REG_0 ].type =PTR_TO_MEM | ret_flag; regs[BPF_REG_0 ].mem_size = tsize; }else { +/* MEM_RDONLY may be carried from ret_flag, but it +* doesn't apply on PTR_TO_BTF_ID. Fold it, otherwise +* it will confuse the check of PTR_TO_BTF_ID in +* check_mem_access(). +*/ + ret_flag &= ~MEM_RDONLY ; + regs[BPF_REG_0 ].type =PTR_TO_BTF_ID | ret_flag; regs[BPF_REG_0 ].btf = meta.ret_btf; regs[BPF_REG_0 ].btf_id = meta.ret_btf_id;
@@ -9172,7 +9194,7 @@ static int check_ld_imm(struct bpf_verifier_env *env, struct bpf_insn *insn)if (insn->src_reg ==BPF_PSEUDO_BTF_ID ) { dst_reg->type = aux->btf_var.reg_type; -switch (dst_reg->type) { +switch (base_type (dst_reg->type)) {case PTR_TO_MEM : dst_reg->mem_size = aux->btf_var.mem_size;break ;
@@ -11313,7 +11335,7 @@ static int check_pseudo_btf_id(struct bpf_verifier_env *env, err = -EINVAL ; goto err_put; } - aux->btf_var.reg_type =PTR_TO_MEM ; + aux->btf_var.reg_type =PTR_TO_MEM |MEM_RDONLY ; aux->btf_var.mem_size = tsize; }else { aux->btf_var.reg_type =PTR_TO_BTF_ID ;
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 8/10 bpf: Add MEM_RDONLY for helper args that are pointers to rdonly mem.
In reply to Hao Luocommit 216e3cd2f28dbbf1fe86848e0e29e6693b9f0a20 upstream.
Some helper functions may modify its arguments, for example, bpf_d_path, bpf_get_stack etc. Previously, their argument types were marked as ARG_PTR_TO_MEM, which is compatible with read-only mem types, such as PTR_TO_RDONLY_BUF. Therefore it's legitimate, but technically incorrect, to modify a read-only memory by passing it into one of such helper functions.
This patch tags the bpf_args compatible with immutable memory with MEM_RDONLY flag. The arguments that don't have this flag will be only compatible with mutable memory types, preventing the helper from modifying a read-only memory. The bpf_args that have MEM_RDONLY are compatible with both mutable memory and immutable memory.
--- include/linux/bpf.h | 4 ++- kernel/bpf/btf.c | 2 +- kernel/bpf/cgroup.c | 2 +- kernel/bpf/helpers.c | 8 ++--- kernel/bpf/ringbuf.c | 2 +- kernel/bpf/syscall.c | 2 +- kernel/bpf/verifier.c | 20 +++++++++++-- kernel/trace/bpf_trace.c | 22 +++++++------- net/core/filter.c | 64 ++++++++++++++++++++-------------------- 9 files changed, 71 insertions(+), 55 deletions(-)
include/linux/bpf.h +3 -1
@@ -307,7 +307,9 @@ enum bpf_type_flag {/* PTR may be NULL. */ PTR_MAYBE_NULL =BIT (0 +BPF_BASE_TYPE_BITS ), -/* MEM is read-only. */ +/* MEM is read-only. When applied on bpf_arg, it indicates the arg is +* compatible with both mutable and immutable memory. +*/ MEM_RDONLY =BIT (1 +BPF_BASE_TYPE_BITS ), __BPF_TYPE_LAST_FLAG = MEM_RDONLY,
kernel/bpf/btf.c +1 -1
@@ -6231,7 +6231,7 @@ const struct bpf_func_proto bpf_btf_find_by_name_kind_proto = { .func = bpf_btf_find_by_name_kind, .gpl_only = false, .ret_type = RET_INTEGER, - .arg1_type = ARG_PTR_TO_MEM, + .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_ANYTHING,
kernel/bpf/cgroup.c +1 -1
@@ -1753,7 +1753,7 @@ static const struct bpf_func_proto bpf_sysctl_set_new_value_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE, };
kernel/bpf/helpers.c +4 -4
@@ -530,7 +530,7 @@ const struct bpf_func_proto bpf_strtol_proto = { .func = bpf_strtol, .gpl_only = false, .ret_type = RET_INTEGER, - .arg1_type = ARG_PTR_TO_MEM, + .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_LONG,
@@ -558,7 +558,7 @@ const struct bpf_func_proto bpf_strtoul_proto = { .func = bpf_strtoul, .gpl_only = false, .ret_type = RET_INTEGER, - .arg1_type = ARG_PTR_TO_MEM, + .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_LONG,
@@ -630,7 +630,7 @@ const struct bpf_func_proto bpf_event_output_data_proto = { .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_CONST_MAP_PTR, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_MEM, + .arg4_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg5_type = ARG_CONST_SIZE_OR_ZERO, };
@@ -1013,7 +1013,7 @@ const struct bpf_func_proto bpf_snprintf_proto = { .arg1_type = ARG_PTR_TO_MEM_OR_NULL, .arg2_type = ARG_CONST_SIZE_OR_ZERO, .arg3_type = ARG_PTR_TO_CONST_STR, - .arg4_type = ARG_PTR_TO_MEM_OR_NULL, + .arg4_type = ARG_PTR_TO_MEM | PTR_MAYBE_NULL | MEM_RDONLY, .arg5_type = ARG_CONST_SIZE_OR_ZERO, };
kernel/bpf/ringbuf.c +1 -1
@@ -444,7 +444,7 @@ const struct bpf_func_proto bpf_ringbuf_output_proto = { .func = bpf_ringbuf_output, .ret_type = RET_INTEGER, .arg1_type = ARG_CONST_MAP_PTR, - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
kernel/bpf/syscall.c +1 -1
@@ -4753,7 +4753,7 @@ static const struct bpf_func_proto bpf_sys_bpf_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_ANYTHING, - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE, };
kernel/bpf/verifier.c +17 -3
@@ -4890,7 +4890,6 @@ static const struct bpf_reg_types mem_types = { PTR_TO_MAP_VALUE,PTR_TO_MEM , PTR_TO_BUF, - PTR_TO_BUF | MEM_RDONLY, }, };
@@ -4960,6 +4959,21 @@ static int check_reg_type(struct bpf_verifier_env *env, u32 regno,return -EFAULT ; } +/* ARG_PTR_TO_MEM + RDONLY is compatible with PTR_TO_MEM and PTR_TO_MEM + RDONLY, +* but ARG_PTR_TO_MEM is compatible only with PTR_TO_MEM and NOT with PTR_TO_MEM + RDONLY +* +* Same for MAYBE_NULL: +* +* ARG_PTR_TO_MEM + MAYBE_NULL is compatible with PTR_TO_MEM and PTR_TO_MEM + MAYBE_NULL, +* but ARG_PTR_TO_MEM is compatible only with PTR_TO_MEM but NOT with PTR_TO_MEM + MAYBE_NULL +* +* Therefore we fold these flags depending on the arg_type before comparison. +*/ +if (arg_type &MEM_RDONLY ) + type &= ~MEM_RDONLY ; +if (arg_type &PTR_MAYBE_NULL ) + type &= ~PTR_MAYBE_NULL ; +for (i =0 ; i <ARRAY_SIZE (compatible->types); i++) { expected = compatible->types[i];if (expected ==NOT_INIT )
@@ -4969,14 +4983,14 @@ static int check_reg_type(struct bpf_verifier_env *env, u32 regno, goto found; } -verbose (env,"R%d type=%s expected=" , regno,reg_type_str (env, type)); +verbose (env,"R%d type=%s expected=" , regno,reg_type_str (env, reg->type));for (j =0 ; j +1 < i; j++)verbose (env,"%s, " ,reg_type_str (env, compatible->types[j]));verbose (env,"%s\n" ,reg_type_str (env, compatible->types[j]));return -EACCES ; found: -if (type ==PTR_TO_BTF_ID ) { +if (reg->type ==PTR_TO_BTF_ID ) {if (!arg_btf_id) {if (!compatible->btf_id) {verbose (env,"verifier internal error: missing arg compatible BTF ID\n" );
kernel/trace/bpf_trace.c +11 -11
@@ -345,7 +345,7 @@ static const struct bpf_func_proto bpf_probe_write_user_proto = { .gpl_only = true, .ret_type = RET_INTEGER, .arg1_type = ARG_ANYTHING, - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE, };
@@ -394,7 +394,7 @@ static const struct bpf_func_proto bpf_trace_printk_proto = { .func = bpf_trace_printk, .gpl_only = true, .ret_type = RET_INTEGER, - .arg1_type = ARG_PTR_TO_MEM, + .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg2_type = ARG_CONST_SIZE, };
@@ -446,9 +446,9 @@ static const struct bpf_func_proto bpf_seq_printf_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &btf_seq_file_ids[0], - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE, - .arg4_type = ARG_PTR_TO_MEM_OR_NULL, + .arg4_type = ARG_PTR_TO_MEM | PTR_MAYBE_NULL | MEM_RDONLY, .arg5_type = ARG_CONST_SIZE_OR_ZERO, };
@@ -463,7 +463,7 @@ static const struct bpf_func_proto bpf_seq_write_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &btf_seq_file_ids[0], - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE_OR_ZERO, };
@@ -487,7 +487,7 @@ static const struct bpf_func_proto bpf_seq_printf_btf_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &btf_seq_file_ids[0], - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
@@ -648,7 +648,7 @@ static const struct bpf_func_proto bpf_perf_event_output_proto = { .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_CONST_MAP_PTR, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_MEM, + .arg4_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg5_type = ARG_CONST_SIZE_OR_ZERO, };
@@ -958,7 +958,7 @@ const struct bpf_func_proto bpf_snprintf_btf_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM, .arg2_type = ARG_CONST_SIZE, - .arg3_type = ARG_PTR_TO_MEM, + .arg3_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg4_type = ARG_CONST_SIZE, .arg5_type = ARG_ANYTHING, };
@@ -1207,7 +1207,7 @@ static const struct bpf_func_proto bpf_perf_event_output_proto_tp = { .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_CONST_MAP_PTR, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_MEM, + .arg4_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg5_type = ARG_CONST_SIZE_OR_ZERO, };
@@ -1429,7 +1429,7 @@ static const struct bpf_func_proto bpf_perf_event_output_proto_raw_tp = { .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_CONST_MAP_PTR, .arg3_type = ARG_ANYTHING, - .arg4_type = ARG_PTR_TO_MEM, + .arg4_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg5_type = ARG_CONST_SIZE_OR_ZERO, };
@@ -1483,7 +1483,7 @@ static const struct bpf_func_proto bpf_get_stack_proto_raw_tp = { .gpl_only = true, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, - .arg2_type = ARG_PTR_TO_MEM, + .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
net/core/filter.c +32 -32
241 lines not on this page · raw message
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 9/10 bpf/selftests: Test PTR_TO_RDONLY_MEM
In reply to Hao Luocommit 9497c458c10b049438ef6e6ddda898edbc3ec6a8 upstream.
This test verifies that a ksym of non-struct can not be directly updated.
--- .../selftests/bpf/prog_tests/ksyms_btf.c | 14 +++++++++ .../bpf/progs/test_ksyms_btf_write_check.c | 29 +++++++++++++++++++ 2 files changed, 43 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_btf_write_check.c
tools/testing/selftests/bpf/prog_tests/ksyms_btf.c +14 -0
@@ -7,6 +7,7 @@#include "test_ksyms_btf.skel.h" #include "test_ksyms_btf_null_check.skel.h" #include "test_ksyms_weak.skel.h" +#include "test_ksyms_btf_write_check.skel.h" static int duration;
@@ -109,6 +110,16 @@ static void test_weak_syms(void)test_ksyms_weak__destroy (skel); } +static void test_write_check (void ) +{ +struct test_ksyms_btf_write_check *skel; + + skel =test_ksyms_btf_write_check__open_and_load (); +ASSERT_ERR_PTR (skel,"unexpected load of a prog writing to ksym memory\n" ); + +test_ksyms_btf_write_check__destroy (skel); +} +void test_ksyms_btf (void ) {int percpu_datasec;
@@ -136,4 +147,7 @@ void test_ksyms_btf(void)if (test__start_subtest ("weak_ksyms" ))test_weak_syms (); + +if (test__start_subtest ("write_check" )) +test_write_check (); }
tools/testing/selftests/bpf/progs/test_ksyms_btf_write_check.c new file +29 -0
@@ -0,0 +1,29 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Google */ + +#include "vmlinux.h" + +#include <bpf/bpf_helpers.h> + +extern const int bpf_prog_active __ksym; /* int type global var. */ + +SEC("raw_tp/sys_enter") +int handler (const void *ctx) +{ +int *active; +__u32 cpu; + + cpu =bpf_get_smp_processor_id (); + active = (int *)bpf_per_cpu_ptr (&bpf_prog_active, cpu); +if (active) { +/* Kernel memory obtained from bpf_{per,this}_cpu_ptr +* is read-only, should _not_ pass verification. +*/ +/* WRITE_ONCE */ + *(volatile int *)active =-1 ; + } + +return 0 ; +} + +char _license[] SEC("license") = "GPL";
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
PATCH 10/10 bpf: Fix crash due to out of bounds access into reg2btf_ids.
In reply to Hao LuoFrom: Kumar Kartikeya Dwivedi <[email protected]>
commit 45ce4b4f9009102cd9f581196d480a59208690c1 upstream
When commit e6ac2450d6de ("bpf: Support bpf program calling kernel function") added kfunc support, it defined reg2btf_ids as a cheap way to translate the verifier reg type to the appropriate btf_vmlinux BTF ID, however
commit c25b2ae13603 ("bpf: Replace PTR_TO_XXX_OR_NULL with PTR_TO_XXX | PTR_MAYBE_NULL") moved the __BPF_REG_TYPE_MAX from the last member of bpf_reg_type enum to after the base register types, and defined other variants using type flag composition. However, now, the direct usage of reg->type to index into reg2btf_ids may no longer fall into __BPF_REG_TYPE_MAX range, and hence lead to out of bounds access and kernel crash on dereference of bad pointer.
[backport note: commit 3363bd0cfbb80 ("bpf: Extend kfunc with PTR_TO_CTX, PTR_TO_MEM
argument support") was introduced after 5.15 and contains an out of bound reg2btf_ids access. Since that commit hasn't been backported, this patch doesn't include fix to that access. If we backport that commit in future, we need to fix its faulting access as well.]
--- kernel/bpf/btf.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/bpf/btf.c +2 -2
@@ -5510,9 +5510,9 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env,if (reg->type ==PTR_TO_BTF_ID ) { reg_btf = reg->btf; reg_ref_id = reg->btf_id; - }else if (reg2btf_ids[reg->type]) { + }else if (reg2btf_ids[base_type (reg->type)]) { reg_btf = btf_vmlinux; - reg_ref_id = *reg2btf_ids[reg->type]; + reg_ref_id = *reg2btf_ids[base_type (reg->type)]; }else { bpf_log(log, "kernel function %s args#%d expected pointer to %s %s but R%d is not a pointer to btf_id\n", func_name, i,
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
Greg KH
maintainerQuoted 12 lines · Hao Luo
Hi Greg,
Please cherry-pick this patch series into 5.15.y stable. It includes a feature that fixes CVE-2022-0500 which allows a user with
cap_bpfprivileges to get root privileges. The patch that fixes the bug ispatch 7/10: bpf: Make
per_cpu_ptrreturn rdonlyThe rest are the depedences required by the fix patch. Note that v5.10 and below are not affected by this bug.
Quoted 6 lines
This patchset has been merged in mainline v5.17 and backported to v5.16[1], except patch 10/10 ("bpf: Fix crash due to out of bounds access into
reg2btf_ids."), which fixes an out-of-bound access in the main feature in this series and hasn't been backported to v5.16 yet. If it's convenient, could you apply patch 10/10 to 5.16? I can send a separate patch for v5.16, if you prefer.
5.16 is long end-of-life, sorry, I can't add any more patches to that tree and no one should be using it anymore.
I'll go queue these up now for 5.15, thanks for the backports!
greg k-h
Quoted 21 lines · Greg KH
Quoted 12 lines · Hao Luo
Hi Greg,
Please cherry-pick this patch series into 5.15.y stable. It includes a feature that fixes CVE-2022-0500 which allows a user with
cap_bpfprivileges to get root privileges. The patch that fixes the bug ispatch 7/10: bpf: Make
per_cpu_ptrreturn rdonlyThe rest are the depedences required by the fix patch. Note that v5.10 and below are not affected by this bug.
Quoted 6 lines
This patchset has been merged in mainline v5.17 and backported to v5.16[1], except patch 10/10 ("bpf: Fix crash due to out of bounds access into
reg2btf_ids."), which fixes an out-of-bound access in the main feature in this series and hasn't been backported to v5.16 yet. If it's convenient, could you apply patch 10/10 to 5.16? I can send a separate patch for v5.16, if you prefer.
Quoted 6 lines
5.16 is long end-of-life, sorry, I can't add any more patches to that tree and no one should be using it anymore.
I'll go queue these up now for 5.15, thanks for the backports!
greg k-h
Thank you Greg! I double checked and found that patch 10/10 is already in v5.16. So we're good.
Hao