selftests/bpf: Add test for cgroup storage OOB read
Subsystems (3)
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH v3 1/2 bpf: Fix OOB in pcpu_init_value
From: Lang Xu <[email protected]>
An out-of-bounds read occurs when copying element from a BPF_MAP_TYPE_CGROUP_STORAGE map to another pcpu map with the same value_size that is not rounded up to 8 bytes.
The issue happens when:
1. A CGROUP_STORAGE map is created with value_size not aligned to 8 bytes (e.g., 4 bytes)
2. A pcpu map is created with the same value_size (e.g., 4 bytes)
3. Update element in 2 with data in 1
pcpu_init_value assumes that all sources are rounded up to 8 bytes, and invokes copy_map_value_long to make a data copy, However, the assumption doesn't stand since there are some cases where the source may not be rounded up to 8 bytes, e.g., CGROUP_STORAGE, skb->data. the verifier verifies exactly the size that the source claims, not the size rounded up to 8 bytes by kernel, an OOB happens when the source has only 4 bytes while the copy size(4) is rounded up to 8.
--- kernel/bpf/hashtab.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/bpf/hashtab.c +1 -1
@@ -1056,7 +1056,7 @@ static void pcpu_init_value(struct bpf_htab *htab, void __percpu *pptr,for_each_possible_cpu (cpu) {if (cpu == current_cpu) -copy_map_value_long (&htab->map,per_cpu_ptr (pptr, cpu), value); +copy_map_value (&htab->map,per_cpu_ptr (pptr, cpu), value);else /* Since elem is preallocated, we cannot touch special fields */ zero_map_value (&htab->map,per_cpu_ptr (pptr, cpu)); }
Signature · 1 line
2.51.0
PATCH v3 2/2 selftests/bpf: Add test for cgroup storage OOB read
In reply to a message not in the archiveFrom: Lang Xu <[email protected]>
Add a test case to reproduce the out-of-bounds read issue when copying from cgroup storage maps with unaligned value_size.
The test creates:
1. A CGROUP_STORAGE map with 4-byte value (not 8-byte aligned)
2. A LRU_PERCPU_HASH map with 4-byte value (same size)
When a socket is created in the cgroup, the BPF program triggers bpf_map_update_elem() which calls copy_map_value_long(). This function rounds up the copy size to 8 bytes, but the cgroup storage buffer is only 4 bytes, causing an OOB read (before the fix).
--- .../selftests/bpf/prog_tests/cgroup_storage.c | 42 ++++++++++++++++++ .../selftests/bpf/progs/cgroup_storage.c | 43 +++++++++++++++++++ 2 files changed, 85 insertions(+)
tools/testing/selftests/bpf/prog_tests/cgroup_storage.c +42 -0
@@ -1,5 +1,7 @@// SPDX-License-Identifier: GPL-2.0 +#include <unistd.h> +#include <sys/socket.h> #include <test_progs.h> #include "cgroup_helpers.h" #include "network_helpers.h"
@@ -94,3 +96,43 @@ void test_cgroup_storage(void)close (cgroup_fd);cleanup_cgroup_environment (); } + +void test_cgroup_storage_oob (void ) +{ +struct cgroup_storage *skel; +int cgroup_fd, sock_fd; + + cgroup_fd =cgroup_setup_and_join (TEST_CGROUP ); +if (!ASSERT_OK_FD (cgroup_fd,"create cgroup" )) +return ; + +/* Load and attach BPF program */ + skel =cgroup_storage__open_and_load (); +if (!ASSERT_OK_PTR (skel,"cgroup_storage__open_and_load" )) + goto cleanup_cgroup; + + skel->links.trigger_oob =bpf_program__attach_cgroup (skel->progs.trigger_oob, + cgroup_fd); +if (!ASSERT_OK_PTR (skel->links.trigger_oob,"attach_cgroup" )) + goto cleanup_skel; + +/* Create a socket to trigger cgroup/sock_create hook. +* This will execute our BPF program and trigger the OOB read +* if the bug is present (before the fix). +*/ + sock_fd =socket (AF_INET ,SOCK_DGRAM ,0 ); +if (!ASSERT_OK_FD (sock_fd,"create socket" )) + goto cleanup_skel; + +close (sock_fd); + +/* If we reach here without a kernel panic or KASAN report, +* the test passes (the fix is working). +*/ + +cleanup_skel: +cgroup_storage__destroy (skel); +cleanup_cgroup: +close (cgroup_fd); +cleanup_cgroup_environment (); +}
tools/testing/selftests/bpf/progs/cgroup_storage.c +43 -0
47 lines not on this page · raw message
Signature · 1 line
2.51.0