bpf: Enforce expected_attach_type for tailcall compatibility
Subsystems (5)
Daniel Borkmann
maintainerPATCH 1/2 bpf: Enforce expected_attach_type for tailcall compatibility
Yinhao et al. recently reported:
Our fuzzer tool discovered an uninitialized pointer issue in the bpf_prog_test_run_xdp() function within the Linux kernel's BPF subsystem. This leads to a NULL pointer dereference when a BPF program attempts to deference the txq member of struct xdp_buff object.
The test initializes two programs of BPF_PROG_TYPE_XDP: progA acts as the entry point for bpf_prog_test_run_xdp() and its expected_attach_type can neither be of be BPF_XDP_DEVMAP nor BPF_XDP_CPUMAP. progA calls into a slot of a tailcall map it owns. progB's expected_attach_type must be BPF_XDP_DEVMAP to pass xdp_is_valid_access() validation. The program returns struct xdp_md's egress_ifindex, and the latter is only allowed to be accessed under mentioned expected_attach_type. progB is then inserted into the tailcall which progA calls.
The underlying issue goes beyond XDP though. Another example are programs of type BPF_PROG_TYPE_CGROUP_SOCK_ADDR. sock_addr_is_valid_access() as well as sock_addr_func_proto() have different logic depending on the programs' expected_attach_type. Similarly, a program attached to BPF_CGROUP_INET4_GETPEERNAME should not be allowed doing a tailcall into a program which calls bpf_bind() out of BPF which is only enabled for BPF_CGROUP_INET4_CONNECT.
In short, specifying expected_attach_type allows to open up additional functionality or restrictions beyond what the basic bpf_prog_type enables. The use of tailcalls must not violate these constraints. Fix it by enforcing expected_attach_type in __bpf_prog_map_compatible().
--- include/linux/bpf.h | 1 + kernel/bpf/core.c | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-)
include/linux/bpf.h +1 -0
@@ -290,6 +290,7 @@ struct bpf_map_owner {bool xdp_has_frags;u64 storage_cookie[MAX_BPF_CGROUP_STORAGE_TYPE ];const struct btf_type *attach_func_proto; +enum bpf_attach_type expected_attach_type; };struct bpf_map {
kernel/bpf/core.c +3 -1
@@ -2361,6 +2361,7 @@ static bool __bpf_prog_map_compatible(struct bpf_map *map, map->owner->type = prog_type; map->owner->jited = fp->jited; map->owner->xdp_has_frags = aux->xdp_has_frags; + map->owner->expected_attach_type = fp->expected_attach_type; map->owner->attach_func_proto = aux->attach_func_proto;for_each_cgroup_storage_type (i) { map->owner->storage_cookie[i] =
@@ -2371,7 +2372,8 @@ static bool __bpf_prog_map_compatible(struct bpf_map *map, }else { ret = map->owner->type == prog_type && map->owner->jited == fp->jited && - map->owner->xdp_has_frags == aux->xdp_has_frags; + map->owner->xdp_has_frags == aux->xdp_has_frags && + map->owner->expected_attach_type == fp->expected_attach_type;for_each_cgroup_storage_type (i) {if (!ret)break ;
Signature · 1 line
2.43.0
Daniel Borkmann
maintainerPATCH 2/2 selftests/bpf: Add test case for different expected_attach_type
Add a small test case which adds two programs - one calling the other through a tailcall - and check that BPF rejects them in case of different expected_attach_type values:
# ./vmtest.sh -- ./test_progs -t xdp_devmap [...] #641/1 xdp_devmap_attach/Verifier check of DEVMAP programs:OK #641 xdp_devmap_attach:OK Summary: 1/1 PASSED, 0 SKIPPED, 0 FAILED
--- .../bpf/prog_tests/xdp_devmap_attach.c | 31 ++++++++++++++++++- .../bpf/progs/test_xdp_devmap_tailcall.c | 29 +++++++++++++++++ 2 files changed, 59 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/progs/test_xdp_devmap_tailcall.c
tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c +30 -1
@@ -7,6 +7,7 @@#include <test_progs.h> #include "test_xdp_devmap_helpers.skel.h" +#include "test_xdp_devmap_tailcall.skel.h" #include "test_xdp_with_devmap_frags_helpers.skel.h" #include "test_xdp_with_devmap_helpers.skel.h"
@@ -107,6 +108,29 @@ static void test_neg_xdp_devmap_helpers(void) } } +static void test_xdp_devmap_tailcall (enum bpf_attach_type prog_dev, +enum bpf_attach_type prog_tail, +bool expect_reject) +{ +struct test_xdp_devmap_tailcall *skel; +int err; + + skel =test_xdp_devmap_tailcall__open (); +if (!ASSERT_OK_PTR (skel,"test_xdp_devmap_tailcall__open" )) +return ; + +bpf_program__set_expected_attach_type (skel->progs.xdp_devmap, prog_dev); +bpf_program__set_expected_attach_type (skel->progs.xdp_entry, prog_tail); + + err =test_xdp_devmap_tailcall__load (skel); +if (expect_reject) +ASSERT_ERR (err,"test_xdp_devmap_tailcall__load" ); +else +ASSERT_OK (err,"test_xdp_devmap_tailcall__load" ); + +test_xdp_devmap_tailcall__destroy (skel); +} +static void test_xdp_with_devmap_frags_helpers (void ) {struct test_xdp_with_devmap_frags_helpers *skel;
@@ -238,8 +262,13 @@ void serial_test_xdp_devmap_attach(void)if (test__start_subtest ("DEVMAP with frags programs in entries" ))test_xdp_with_devmap_frags_helpers (); -if (test__start_subtest ("Verifier check of DEVMAP programs" )) +if (test__start_subtest ("Verifier check of DEVMAP programs" )) {test_neg_xdp_devmap_helpers (); +test_xdp_devmap_tailcall (BPF_XDP_DEVMAP ,BPF_XDP_DEVMAP , false); +test_xdp_devmap_tailcall (0 ,0 , true); +test_xdp_devmap_tailcall (BPF_XDP_DEVMAP ,0 , true); +test_xdp_devmap_tailcall (0 ,BPF_XDP_DEVMAP , true); + }if (test__start_subtest ("DEVMAP with programs in entries on veth" ))test_xdp_with_devmap_helpers_veth ();
tools/testing/selftests/bpf/progs/test_xdp_devmap_tailcall.c new file +29 -0
@@ -0,0 +1,29 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +SEC("xdp") +int xdp_devmap (struct xdp_md *ctx) +{ +return ctx->egress_ifindex; +} + +struct { + __uint(type, BPF_MAP_TYPE_PROG_ARRAY); + __uint(max_entries, 1); + __uint(key_size, sizeof(__u32)); + __array(values, int (void *)); +} xdp_map SEC(".maps") = { + .values = { + [0 ] = (void *)&xdp_devmap, + }, +}; + +SEC("xdp") +int xdp_entry (struct xdp_md *ctx) +{ +bpf_tail_call (ctx, &xdp_map,0 ); +return 0 ; +}
Signature · 1 line
2.43.0