Patch "bpf: prevent out-of-bounds speculation" has been added to the 4.9-stable tree
Subsystems (3)
This is a note to let you know that I've just added the patch titled
bpf: prevent out-of-bounds speculation
to the 4.9-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary
The filename of the patch is:
bpf-prevent-out-of-bounds-speculation.patch
and it can be found in the queue-4.9 subdirectory.
If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.
Quoted 1 line
From
b2157399cc9898260d6031c5bfe45fe137c1fbe7Mon Sep 17 00:00:00 2001
From: Alexei Starovoitov <[email protected]>
Date: Sun, 7 Jan 2018 17:33:02 -0800
Subject: bpf: prevent out-of-bounds speculation
From: Alexei Starovoitov <[email protected]>
commit b2157399cc9898260d6031c5bfe45fe137c1fbe7 upstream.
Under speculation, CPUs may mis-predict branches in bounds checks. Thus, memory accesses under a bounds check may be speculated even if the bounds check fails, providing a primitive for building a side channel.
To avoid leaking kernel data round up array-based maps and mask the index after bounds check, so speculated load with out of bounds index will load either valid value from the array or zero from the padded area.
Unconditionally mask index for all array types even when max_entries are not rounded to power of 2 for root user.
When map is created by unpriv user generate a sequence of bpf insns that includes AND operation to make sure that JITed code includes the same 'index & index_mask' operation.
If prog_array map is created by unpriv user replace
bpf_tail_call(ctx, map, index);
with
if (index >= max_entries) {
index &= map->index_mask;
bpf_tail_call(ctx, map, index); }
(along with roundup to power 2) to prevent out-of-bounds speculation. There is secondary redundant 'if (index >= max_entries)' in the interpreter and in all JITs, but they can be optimized later if necessary.
Other array-like maps (cpumap, devmap, sockmap, perf_event_array, cgroup_array) cannot be used by unpriv, so no changes there.
That fixes bpf side of "Variant 1: bounds check bypass (CVE-2017-5753)" on all architectures with and without JIT.
v2->v3:
Daniel noticed that attack potentially can be crafted via syscall commands without loading the program, so add masking to those paths as well.
--- include/linux/bpf.h | 2 ++ include/linux/bpf_verifier.h | 5 ++++- kernel/bpf/arraymap.c | 31 ++++++++++++++++++++++--------- kernel/bpf/verifier.c | 42 +++++++++++++++++++++++++++++++++++++++--- 4 files changed, 67 insertions(+), 13 deletions(-)
include/linux/bpf.h +2 -0
@@ -43,6 +43,7 @@ struct bpf_map {u32 max_entries;u32 map_flags;u32 pages; +bool unpriv_array;struct user_struct *user;const struct bpf_map_ops *ops;struct work_struct work;
@@ -189,6 +190,7 @@ struct bpf_prog_aux {struct bpf_array {struct bpf_map map;u32 elem_size; +u32 index_mask;/* 'ownership' of prog_array is claimed by the first program that * is going to use this map or by the first program which FD is stored * in the map to make sure that all callers and callees have the same
include/linux/bpf_verifier.h +4 -1
@@ -67,7 +67,10 @@ struct bpf_verifier_state_list { };struct bpf_insn_aux_data { -enum bpf_reg_type ptr_type;/* pointer type for load/store insns */ +union { +enum bpf_reg_type ptr_type;/* pointer type for load/store insns */ +struct bpf_map *map_ptr;/* pointer for call insn into lookup_elem */ + };bool seen;/* this insn was processed by the verifier */ };
kernel/bpf/arraymap.c +22 -9
@@ -46,9 +46,10 @@ static int bpf_array_alloc_percpu(structstatic struct bpf_map *array_map_alloc (union bpf_attr *attr) {bool percpu = attr->map_type ==BPF_MAP_TYPE_PERCPU_ARRAY ; +u32 elem_size, index_mask, max_entries; +bool unpriv = !capable (CAP_SYS_ADMIN );struct bpf_array *array;u64 array_size; -u32 elem_size;/* check sanity of attributes */ if (attr->max_entries == 0 || attr->key_size != 4 ||
@@ -63,11 +64,20 @@ static struct bpf_map *array_map_alloc(u elem_size =round_up (attr->value_size,8 ); + max_entries = attr->max_entries; + index_mask =roundup_pow_of_two (max_entries) -1 ; + +if (unpriv) +/* round up array size to nearest power of 2, +* since cpu will speculate within index_mask limits +*/ + max_entries = index_mask +1 ; + array_size =sizeof (*array);if (percpu) - array_size += (u64 ) attr->max_entries *sizeof (void *); + array_size += (u64 ) max_entries *sizeof (void *);else - array_size += (u64 ) attr->max_entries * elem_size; + array_size += (u64 ) max_entries * elem_size;/* make sure there is no u32 overflow later in round_up() */ if (array_size >=U32_MAX -PAGE_SIZE )
@@ -77,6 +87,8 @@ static struct bpf_map *array_map_alloc(u array =bpf_map_area_alloc (array_size);if (!array)return ERR_PTR (-ENOMEM ); + array->index_mask = index_mask; + array->map.unpriv_array = unpriv;/* copy mandatory map attributes */ array->map.map_type = attr->map_type;
@@ -110,7 +122,7 @@ static void *array_map_lookup_elem(strucif (unlikely (index >= array->map.max_entries))return NULL ; -return array->value + array->elem_size * index; +return array->value + array->elem_size * (index & array->index_mask); }/* Called from eBPF program */
@@ -122,7 +134,7 @@ static void *percpu_array_map_lookup_eleif (unlikely (index >= array->map.max_entries))return NULL ; -return this_cpu_ptr (array->pptrs[index]); +return this_cpu_ptr (array->pptrs[index & array->index_mask]); }int bpf_percpu_array_copy (struct bpf_map *map,void *key,void *value)
@@ -142,7 +154,7 @@ int bpf_percpu_array_copy(struct bpf_map*/ size =round_up (map->value_size,8 );rcu_read_lock (); - pptr = array->pptrs[index]; + pptr = array->pptrs[index & array->index_mask];for_each_possible_cpu (cpu) {bpf_long_memcpy (value + off,per_cpu_ptr (pptr, cpu), size); off += size;
@@ -190,10 +202,11 @@ static int array_map_update_elem(structreturn -EEXIST ;if (array->map.map_type ==BPF_MAP_TYPE_PERCPU_ARRAY ) -memcpy (this_cpu_ptr (array->pptrs[index]), +memcpy (this_cpu_ptr (array->pptrs[index & array->index_mask]), value, map->value_size);else -memcpy (array->value + array->elem_size * index, +memcpy (array->value + + array->elem_size * (index & array->index_mask), value, map->value_size);return 0 ; }
@@ -227,7 +240,7 @@ int bpf_percpu_array_update(struct bpf_m*/ size =round_up (map->value_size,8 );rcu_read_lock (); - pptr = array->pptrs[index]; + pptr = array->pptrs[index & array->index_mask];for_each_possible_cpu (cpu) {bpf_long_memcpy (per_cpu_ptr (pptr, cpu), value + off, size); off += size;
kernel/bpf/verifier.c +39 -3
72 lines not on this page · raw message
Patches currently in stable-queue which might be from [email protected] are
queue-4.9/bpf-refactor-fixup_bpf_calls.patch queue-4.9/bpf-array-fix-overflow-in-max_entries-and-undefined-behavior-in-index_mask.patch queue-4.9/bpf-prevent-out-of-bounds-speculation.patch queue-4.9/bpf-move-fixup_bpf_calls-function.patch