Fix for untrusted BTF pointer writes
Subsystems (4)
Kumar Kartikeya Dwivedi
maintainercover Fix for untrusted BTF pointer writes
When using custom btf_struct_access() callbacks, we miss rejecting unstrusted BTF pointer writes. Fix and add a selftest for coverage.
Kumar Kartikeya Dwivedi (1):
selftests/bpf: Add untrusted BTF write regression
Nicholas Dudar (1):
bpf: Reject writes through untrusted BTF pointers
kernel/bpf/verifier.c | 8 ++++-- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 12 +++++++++ .../bpf/progs/tcp_ca_untrusted_btf_write.c | 26 +++++++++++++++++++ 3 files changed, 44 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c
base-commit: f425a0443b7f0221a4b34f6acc0c2924bf5877f2
Signature · 1 line
2.53.0
Kumar Kartikeya Dwivedi
maintainerPATCH 1/2 bpf: Reject writes through untrusted BTF pointers
From: Nicholas Dudar <[email protected]>
check_ptr_to_btf_access() lets program-type btf_struct_access callbacks validate writes before the default BTF access path rejects non-read accesses. That bypasses the read-only policy for untrusted BTF pointers created by helpers such as bpf_rdonly_cast().
Reject non-read accesses through PTR_UNTRUSTED BTF pointers at the common entry point, before the callback branch to handle all cases.
--- kernel/bpf/verifier.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +6 -2
@@ -5813,6 +5813,11 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env,return -EACCES ; } +if (atype !=BPF_READ && (type_flag (reg->type) &PTR_UNTRUSTED )) { +verbose (env,"only read is supported\n" ); +return -EACCES ; + } +if (env->ops->btf_struct_access && !type_is_alloc (reg->type) && atype ==BPF_WRITE ) {if (!btf_is_kernel (reg->btf)) {verifier_bug (env,"reg->btf must be kernel btf" );
@@ -5825,8 +5830,7 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env, reg_arg_name(env, argno), tname, off, size); }else {/* Writes are permitted with default btf_struct_access for -* program allocated objects (which always have id > 0), -* but not for untrusted PTR_TO_BTF_ID | MEM_ALLOC. +* program allocated objects (which always have id > 0). */ if (atype !=BPF_READ && !type_is_ptr_alloc_obj (reg->type)) {verbose (env,"only read is supported\n" );
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH bpf-next v1 1/2] bpf: Reject writes through untrusted BTF pointers
This fixes a write path that bypassed the read-only policy for untrusted BTF pointers, but there is no Fixes: tag.
Quoted 10 lines
check_ptr_to_btf_access()lets program-typebtf_struct_accesscallbacks validate writes before the default BTF access path rejects non-read accesses. That bypasses the read-only policy for untrusted BTF pointers created by helpers such asbpf_rdonly_cast().Reject non-read accesses through
PTR_UNTRUSTEDBTF pointers at the common entry point, before the callback branch to handle all cases.Signed-off-by Nicholas Dudar <[email protected]>Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>
This fixes a write path that bypassed the read-only policy for untrusted BTF pointers, but there is no Fixes: tag.
The write-dispatch branch that took precedence over the untrusted read-only check in check_ptr_to_btf_access(), along with the "but not for untrusted PTR_TO_BTF_ID | MEM_ALLOC" comment that this patch removes, was added when program allocated objects support was introduced.
Should this include:
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/28892378159
Re: [PATCH bpf-next v1 1/2] bpf: Reject writes through untrusted BTF pointers
In reply to Kumar Kartikeya DwivediQuoted 8 lines · Kumar Kartikeya Dwivedi
From: Nicholas Dudar <[email protected]>
check_ptr_to_btf_access()lets program-typebtf_struct_accesscallbacks validate writes before the default BTF access path rejects non-read accesses. That bypasses the read-only policy for untrusted BTF pointers created by helpers such asbpf_rdonly_cast().
Quoted 5 lines
Reject non-read accesses through
PTR_UNTRUSTEDBTF pointers at the common entry point, before the callback branch to handle all cases.Signed-off-by Nicholas Dudar <[email protected]>Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>
Quoted 34 lines
--- kernel/bpf/verifier.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)kernel/bpf/verifier.c +6
-3@@ -5813,6 +5813,11 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env,return -EACCES ; } +if (atype !=BPF_READ && (type_flag (reg->type) &PTR_UNTRUSTED )) { +verbose (env,"only read is supported\n" ); +return -EACCES ; + } +if (env->ops->btf_struct_access && !type_is_alloc (reg->type) && atype ==BPF_WRITE ) {if (!btf_is_kernel (reg->btf)) {verifier_bug (env,"reg->btf must be kernel btf" );@@ -5825,8 +5830,7 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env, reg_arg_name(env, argno), tname, off, size); }else {/* Writes are permitted with default btf_struct_access for -* program allocated objects (which always have id > 0), -* but not for untrusted PTR_TO_BTF_ID | MEM_ALLOC. +* program allocated objects (which always have id > 0). */ if (atype !=BPF_READ && !type_is_ptr_alloc_obj (reg->type)) {verbose (env,"only read is supported\n" ); --2.53.0
Kumar Kartikeya Dwivedi
maintainerPATCH 2/2 selftests/bpf: Add untrusted BTF write regression
In reply to Kumar Kartikeya DwivediAdd a TCP congestion-control struct_ops load test for a write through a BTF pointer produced by bpf_rdonly_cast().
The test expects the verifier to reject the program before the TCP CA btf_struct_access callback can whitelist the tcp_sock field write.
--- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 12 +++++++++ .../bpf/progs/tcp_ca_untrusted_btf_write.c | 26 +++++++++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c
tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c +12 -0
@@ -14,6 +14,7 @@#include "tcp_ca_incompl_cong_ops.skel.h" #include "tcp_ca_unsupp_cong_op.skel.h" #include "tcp_ca_kfunc.skel.h" +#include "tcp_ca_untrusted_btf_write.skel.h" #include "bpf_cc_cubic.skel.h" static const unsigned int total_bytes =10 *1024 *1024 ;
@@ -579,6 +580,15 @@ static void test_tcp_ca_kfunc(void)tcp_ca_kfunc__destroy (skel); } +static void test_untrusted_btf_write (void ) +{ +struct tcp_ca_untrusted_btf_write *skel; + + skel =tcp_ca_untrusted_btf_write__open_and_load (); +ASSERT_ERR_PTR (skel,"tcp_ca_untrusted_btf_write__open_and_load" ); +tcp_ca_untrusted_btf_write__destroy (skel); +} +static void test_cc_cubic (void ) {struct cb_opts cb_opts = {
@@ -637,6 +647,8 @@ void test_bpf_tcp_ca(void)test_link_replace ();if (test__start_subtest ("tcp_ca_kfunc" ))test_tcp_ca_kfunc (); +if (test__start_subtest ("untrusted_btf_write" )) +test_untrusted_btf_write ();if (test__start_subtest ("cc_cubic" ))test_cc_cubic ();if (test__start_subtest ("dctcp_autoattach_map" ))
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +26 -0
@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "bpf_tracing_net.h" +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +SEC("struct_ops") +void BPF_PROG (untrusted_btf_write_init ,struct sock *sk) +{ +struct tcp_sock *tp; +int v =1 ; +void *p; + + p =bpf_rdonly_cast (&v,0 ); + tp = bpf_rdonly_cast(p, bpf_core_type_id_kernel(struct tcp_sock)); + tp->snd_cwnd =1 ; +} + +SEC(".struct_ops") +struct tcp_congestion_ops untrusted_btf_write = { + .init = (void *)untrusted_btf_write_init, + .name ="bpf_ro_btf" , +};
Signature · 1 line
2.53.0
Re: [PATCH bpf-next v1 2/2] selftests/bpf: Add untrusted BTF write regression
Quoted 65 lines · Kumar Kartikeya Dwivedi
Add a TCP congestion-control
struct_opsload test for a write through a BTF pointer produced bybpf_rdonly_cast().The test expects the verifier to reject the program before the TCP CA
btf_struct_accesscallback can whitelist thetcp_sockfield write.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 12 +++++++++ .../bpf/progs/tcp_ca_untrusted_btf_write.c | 26 +++++++++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.ctools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c +12
-0@@ -14,6 +14,7 @@#include "tcp_ca_incompl_cong_ops.skel.h" #include "tcp_ca_unsupp_cong_op.skel.h" #include "tcp_ca_kfunc.skel.h" +#include "tcp_ca_untrusted_btf_write.skel.h" #include "bpf_cc_cubic.skel.h" static const unsigned int total_bytes =10 *1024 *1024 ;@@ -579,6 +580,15 @@ static void test_tcp_ca_kfunc(void)tcp_ca_kfunc__destroy (skel); } +static void test_untrusted_btf_write (void ) +{ +struct tcp_ca_untrusted_btf_write *skel; + + skel =tcp_ca_untrusted_btf_write__open_and_load (); +ASSERT_ERR_PTR (skel,"tcp_ca_untrusted_btf_write__open_and_load" ); +tcp_ca_untrusted_btf_write__destroy (skel); +} +static void test_cc_cubic (void ) {struct cb_opts cb_opts = {@@ -637,6 +647,8 @@ void test_bpf_tcp_ca(void)test_link_replace ();if (test__start_subtest ("tcp_ca_kfunc" ))test_tcp_ca_kfunc (); +if (test__start_subtest ("untrusted_btf_write" )) +test_untrusted_btf_write ();if (test__start_subtest ("cc_cubic" ))test_cc_cubic ();if (test__start_subtest ("dctcp_autoattach_map" ))tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +8
-0@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "bpf_tracing_net.h" +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL";
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c line 18
Quoted 10 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +10
-0+ +SEC("struct_ops") +void BPF_PROG (untrusted_btf_write_init ,struct sock *sk) +{ +struct tcp_sock *tp; +int v =1 ; +void *p; + + p =bpf_rdonly_cast (&v,0 ); + tp = bpf_rdonly_cast(p, bpf_core_type_id_kernel(struct tcp_sock));
Do we need two bpf_rdonly_cast()? I tested the following and it also works:
tp = bpf_rdonly_cast(&v, bpf_core_type_id_kernel(struct tcp_sock));
Quoted 12 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +8
-1+ tp->snd_cwnd =1 ; +} + +SEC(".struct_ops") +struct tcp_congestion_ops untrusted_btf_write = { + .init = (void *)untrusted_btf_write_init, + .name ="bpf_ro_btf" , +}; --2.53.0
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v1 2/2] selftests/bpf: Add untrusted BTF write regression
Quoted 71 lines · Amery Hung
Quoted 69 lines · Kumar Kartikeya Dwivedi
Add a TCP congestion-control
struct_opsload test for a write through a BTF pointer produced bybpf_rdonly_cast().The test expects the verifier to reject the program before the TCP CA
btf_struct_accesscallback can whitelist thetcp_sockfield write.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 12 +++++++++ .../bpf/progs/tcp_ca_untrusted_btf_write.c | 26 +++++++++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.ctools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c +12
-0@@ -14,6 +14,7 @@#include "tcp_ca_incompl_cong_ops.skel.h" #include "tcp_ca_unsupp_cong_op.skel.h" #include "tcp_ca_kfunc.skel.h" +#include "tcp_ca_untrusted_btf_write.skel.h" #include "bpf_cc_cubic.skel.h" static const unsigned int total_bytes =10 *1024 *1024 ;@@ -579,6 +580,15 @@ static void test_tcp_ca_kfunc(void)tcp_ca_kfunc__destroy (skel); } +static void test_untrusted_btf_write (void ) +{ +struct tcp_ca_untrusted_btf_write *skel; + + skel =tcp_ca_untrusted_btf_write__open_and_load (); +ASSERT_ERR_PTR (skel,"tcp_ca_untrusted_btf_write__open_and_load" ); +tcp_ca_untrusted_btf_write__destroy (skel); +} +static void test_cc_cubic (void ) {struct cb_opts cb_opts = {@@ -637,6 +647,8 @@ void test_bpf_tcp_ca(void)test_link_replace ();if (test__start_subtest ("tcp_ca_kfunc" ))test_tcp_ca_kfunc (); +if (test__start_subtest ("untrusted_btf_write" )) +test_untrusted_btf_write ();if (test__start_subtest ("cc_cubic" ))test_cc_cubic ();if (test__start_subtest ("dctcp_autoattach_map" ))tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +12
-0@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "bpf_tracing_net.h" +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +SEC("struct_ops") +void BPF_PROG (untrusted_btf_write_init ,struct sock *sk) +{
Quoted 9 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c line 18
Quoted 6 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +6
-0+struct tcp_sock *tp; +int v =1 ; +void *p; + + p =bpf_rdonly_cast (&v,0 ); + tp = bpf_rdonly_cast(p, bpf_core_type_id_kernel(struct tcp_sock));Do we need two
bpf_rdonly_cast()? I tested the following and it also works:
Yeah, single case works too, I mostly kept these two because of the original report.
Quoted 14 lines
tp = bpf_rdonly_cast(&v, bpf_core_type_id_kernel(struct tcp_sock));Quoted 12 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +8
-1+ tp->snd_cwnd =1 ; +} + +SEC(".struct_ops") +struct tcp_congestion_ops untrusted_btf_write = { + .init = (void *)untrusted_btf_write_init, + .name ="bpf_ro_btf" , +}; --2.53.0
Amery Hung
Reviewed-byRe: [PATCH bpf-next v1 2/2] selftests/bpf: Add untrusted BTF write regression
Quoted 83 lines · Kumar Kartikeya Dwivedi
Quoted 71 lines · Amery Hung
Quoted 69 lines · Kumar Kartikeya Dwivedi
Add a TCP congestion-control
struct_opsload test for a write through a BTF pointer produced bybpf_rdonly_cast().The test expects the verifier to reject the program before the TCP CA
btf_struct_accesscallback can whitelist thetcp_sockfield write.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 12 +++++++++ .../bpf/progs/tcp_ca_untrusted_btf_write.c | 26 +++++++++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.ctools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c +12
-0@@ -14,6 +14,7 @@#include "tcp_ca_incompl_cong_ops.skel.h" #include "tcp_ca_unsupp_cong_op.skel.h" #include "tcp_ca_kfunc.skel.h" +#include "tcp_ca_untrusted_btf_write.skel.h" #include "bpf_cc_cubic.skel.h" static const unsigned int total_bytes =10 *1024 *1024 ;@@ -579,6 +580,15 @@ static void test_tcp_ca_kfunc(void)tcp_ca_kfunc__destroy (skel); } +static void test_untrusted_btf_write (void ) +{ +struct tcp_ca_untrusted_btf_write *skel; + + skel =tcp_ca_untrusted_btf_write__open_and_load (); +ASSERT_ERR_PTR (skel,"tcp_ca_untrusted_btf_write__open_and_load" ); +tcp_ca_untrusted_btf_write__destroy (skel); +} +static void test_cc_cubic (void ) {struct cb_opts cb_opts = {@@ -637,6 +647,8 @@ void test_bpf_tcp_ca(void)test_link_replace ();if (test__start_subtest ("tcp_ca_kfunc" ))test_tcp_ca_kfunc (); +if (test__start_subtest ("untrusted_btf_write" )) +test_untrusted_btf_write ();if (test__start_subtest ("cc_cubic" ))test_cc_cubic ();if (test__start_subtest ("dctcp_autoattach_map" ))tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +12
-0@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "bpf_tracing_net.h" +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +SEC("struct_ops") +void BPF_PROG (untrusted_btf_write_init ,struct sock *sk) +{Quoted 9 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c line 18
Quoted 6 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +6
-0+struct tcp_sock *tp; +int v =1 ; +void *p; + + p =bpf_rdonly_cast (&v,0 ); + tp = bpf_rdonly_cast(p, bpf_core_type_id_kernel(struct tcp_sock));Do we need two
bpf_rdonly_cast()? I tested the following and it also works:
Quoted 2 lines
Yeah, single case works too, I mostly kept these two because of the original report.
I see. I was wondering whether the first cast has some special purposes. Single cast reads a bit cleaner to me, but no strong preference.
Quoted 16 lines
Quoted 15 lines
tp = bpf_rdonly_cast(&v, bpf_core_type_id_kernel(struct tcp_sock));Quoted 12 lines
tools/testing/selftests/bpf/progs/tcp_ca_untrusted_btf_write.c new file +8
-1+ tp->snd_cwnd =1 ; +} + +SEC(".struct_ops") +struct tcp_congestion_ops untrusted_btf_write = { + .init = (void *)untrusted_btf_write_init, + .name ="bpf_ro_btf" , +}; --2.53.0