bpf: Fix SOCK_OPS_GET_SK same-register OOB read in sock_ops and add selftest
Subsystems (6)
v3 cover bpf: Fix SOCK_OPS_GET_SK same-register OOB read in sock_ops and add selftest
When a BPF sock_ops program accesses ctx fields with dst_reg == src_reg, the SOCK_OPS_GET_SK() and SOCK_OPS_GET_FIELD() macros fail to zero the destination register in the !fullsock / !locked_tcp_sock path, leading to OOB read (GET_SK) and kernel pointer leak (GET_FIELD).
Patch 1: Fix both macros by adding BPF_MOV64_IMM(si->dst_reg, 0) in the !fullsock landing pad.
Patch 2: Add selftests covering same-register and different-register cases for both GET_SK and GET_FIELD.
[1] https://lore.kernel.org/bpf/[email protected]/T/#u
Changes since v2:
https://lore.kernel.org/bpf/[email protected]/
- Addressed selftest review from Martin KaFai Lau: removed unused skel parameter, renamed to test_ns_ for automatic netns, ASSERT_GE -> ASSERT_OK_FD
- Add reviewed-by tags.
Changes since v1:
https://lore.kernel.org/bpf/[email protected]/
- Fixed the same bug in SOCK_OPS_GET_FIELD() (pointed out by AI review)
- Added SOCK_OPS_GET_FIELD same-register and GET_SK different-register subtests
Jiayuan Chen (2):
bpf: Fix same-register dst/src OOB read and pointer leak in sock_ops selftests/bpf: Add tests for sock_ops ctx access with same src/dst
register
net/core/filter.c | 6 +- .../bpf/prog_tests/sock_ops_get_sk.c | 76 ++++++++++++ .../selftests/bpf/progs/sock_ops_get_sk.c | 117 ++++++++++++++++++ 3 files changed, 197 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/sock_ops_get_sk.c create mode 100644 tools/testing/selftests/bpf/progs/sock_ops_get_sk.c
Signature · 1 line
2.43.0
PATCH v3 1/2 bpf: Fix same-register dst/src OOB read and pointer leak in sock_ops
When a BPF sock_ops program accesses ctx fields with dst_reg == src_reg, the SOCK_OPS_GET_SK() and SOCK_OPS_GET_FIELD() macros fail to zero the destination register in the !fullsock / !locked_tcp_sock path.
Both macros borrow a temporary register to check is_fullsock / is_locked_tcp_sock when dst_reg == src_reg, because dst_reg holds the ctx pointer. When the check is false (e.g., TCP_NEW_SYN_RECV state with a request_sock), dst_reg should be zeroed but is not, leaving the stale ctx pointer:
- SOCK_OPS_GET_SK: dst_reg retains the ctx pointer, passes NULL checks as PTR_TO_SOCKET_OR_NULL, and can be used as a bogus socket pointer, leading to stack-out-of-bounds access in helpers like bpf_skc_to_tcp6_sock().
- SOCK_OPS_GET_FIELD: dst_reg retains the ctx pointer which the verifier believes is a SCALAR_VALUE, leaking a kernel pointer.
Fix both macros by:
- Changing JMP_A(1) to JMP_A(2) in the fullsock path to skip the added instruction.
- Adding BPF_MOV64_IMM(si->dst_reg, 0) after the temp register restore in the !fullsock path, placed after the restore because dst_reg == src_reg means we need src_reg intact to read ctx->temp.
--- net/core/filter.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
net/core/filter.c +4 -2
@@ -10581,10 +10581,11 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type, si->dst_reg, si->dst_reg, \ offsetof(OBJ, OBJ_FIELD)); \if (si->dst_reg == si->src_reg) { \ - *insn++ =BPF_JMP_A (1 ); \ + *insn++ =BPF_JMP_A (2 ); \ *insn++ =BPF_LDX_MEM (BPF_DW , reg, si->src_reg, \ offsetof(struct bpf_sock_ops_kern , \ temp)); \ + *insn++ =BPF_MOV64_IMM (si->dst_reg,0 ); \ } \ }while (0 )
@@ -10618,10 +10619,11 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type, si->dst_reg, si->src_reg, \ offsetof(struct bpf_sock_ops_kern, sk));\if (si->dst_reg == si->src_reg) { \ - *insn++ =BPF_JMP_A (1 ); \ + *insn++ =BPF_JMP_A (2 ); \ *insn++ =BPF_LDX_MEM (BPF_DW , reg, si->src_reg, \ offsetof(struct bpf_sock_ops_kern , \ temp)); \ + *insn++ =BPF_MOV64_IMM (si->dst_reg,0 ); \ } \ }while (0 )
Signature · 1 line
2.43.0
Re: [PATCH bpf v3 1/2] bpf: Fix same-register dst/src OOB read and pointer leak in sock_ops
Quoted 58 lines · Jiayuan Chen
When a BPF
sock_opsprogram accesses ctx fields withdst_reg==src_reg, theSOCK_OPS_GET_SK()andSOCK_OPS_GET_FIELD()macros fail to zero the destination register in the !fullsock / !locked_tcp_sock path.Both macros borrow a temporary register to check
is_fullsock/is_locked_tcp_sockwhendst_reg==src_reg, becausedst_regholds the ctx pointer. When the check is false (e.g.,TCP_NEW_SYN_RECVstate with arequest_sock),dst_regshould be zeroed but is not, leaving the stale ctx pointer:-
SOCK_OPS_GET_SK:dst_regretains the ctx pointer, passes NULL checks asPTR_TO_SOCKET_OR_NULL, and can be used as a bogus socket pointer, leading to stack-out-of-bounds access in helpers likebpf_skc_to_tcp6_sock().-
SOCK_OPS_GET_FIELD:dst_regretains the ctx pointer which the verifier believes is aSCALAR_VALUE, leaking a kernel pointer.Fix both macros by:
- ChangingJMP_A(1)toJMP_A(2)in the fullsock path to skip the added instruction.
- AddingBPF_MOV64_IMM(si->dst_reg, 0)after the temp register restore in the !fullsock path, placed after the restore becausedst_reg==src_regmeans we needsrc_regintact to readctx->temp.Fixes fd09af010788 ("bpf: sock_ops ctx access may stomp registers in corner case")Fixes 84f44df664e9 ("bpf: sock_ops sk access may stomp registers when dst_reg = src_reg")Reported-by Quan Sun <[email protected]>Reported-by Yinhao Hu <[email protected]>Reported-by Kaiyan Mei <[email protected]>Reported-by Dongliang Mu <[email protected]>Reviewed-by Emil Tsalapatis <[email protected]>Signed-off-by Jiayuan Chen <[email protected]>--- net/core/filter.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)net/core/filter.c +2
-1@@ -10581,10 +10581,11 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type, si->dst_reg, si->dst_reg, \ offsetof(OBJ, OBJ_FIELD)); \if (si->dst_reg == si->src_reg) { \ - *insn++ =BPF_JMP_A (1 ); \ + *insn++ =BPF_JMP_A (2 ); \ *insn++ =BPF_LDX_MEM (BPF_DW , reg, si->src_reg, \ offsetof(struct bpf_sock_ops_kern , \ temp)); \ + *insn++ =BPF_MOV64_IMM (si->dst_reg,0 ); \ } \ }while (0 )@@ -10618,10 +10619,11 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type, si->dst_reg, si->src_reg, \ offsetof(struct bpf_sock_ops_kern, sk));\
net/core/filter.c static u32 sock_ops_convert_ctx_access(enum bpf_access_type type, · line 10629
Quoted 10 lines
net/core/filter.c +2
-1if (si->dst_reg == si->src_reg) { \ - *insn++ =BPF_JMP_A (1 ); \ + *insn++ =BPF_JMP_A (2 ); \ *insn++ =BPF_LDX_MEM (BPF_DW , reg, si->src_reg, \ offsetof(struct bpf_sock_ops_kern , \ temp)); \ + *insn++ =BPF_MOV64_IMM (si->dst_reg,0 ); \ } \ }while (0 )
Sorry Martin, I forgot to include your Acked-by tag. You can add it when applying, or I'll bring it in v4 if revisions are needed.
PATCH v3 2/2 selftests/bpf: Add tests for sock_ops ctx access with same src/dst register
In reply to Jiayuan ChenAdd selftests to verify SOCK_OPS_GET_SK() and SOCK_OPS_GET_FIELD() correctly return NULL/zero when dst_reg == src_reg and is_fullsock == 0.
Three subtests are included:
- get_sk: ctx->sk with same src/dst register (SOCK_OPS_GET_SK)
- get_field: ctx->snd_cwnd with same src/dst register (SOCK_OPS_GET_FIELD)
- get_sk_diff_reg: ctx->sk with different src/dst register (baseline)
Each BPF program uses inline asm (__naked) to force specific register allocation, reads is_fullsock first, then loads the field using the same (or different) register. The test triggers TCP_NEW_SYN_RECV via a TCP handshake and checks that the result is NULL/zero when is_fullsock == 0.
--- .../bpf/prog_tests/sock_ops_get_sk.c | 76 ++++++++++++ .../selftests/bpf/progs/sock_ops_get_sk.c | 117 ++++++++++++++++++ 2 files changed, 193 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/sock_ops_get_sk.c create mode 100644 tools/testing/selftests/bpf/progs/sock_ops_get_sk.c
tools/testing/selftests/bpf/prog_tests/sock_ops_get_sk.c new file +76 -0
@@ -0,0 +1,76 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include "cgroup_helpers.h" +#include "network_helpers.h" +#include "sock_ops_get_sk.skel.h" + +/* See progs/sock_ops_get_sk.c for the bug description. */ +static void run_sock_ops_test (int cgroup_fd,int prog_fd) +{ +int server_fd, client_fd, err; + + err =bpf_prog_attach (prog_fd, cgroup_fd,BPF_CGROUP_SOCK_OPS ,0 ); +if (!ASSERT_OK (err,"prog_attach" )) +return ; + + server_fd =start_server (AF_INET ,SOCK_STREAM ,NULL ,0 ,0 ); +if (!ASSERT_OK_FD (server_fd,"start_server" )) + goto detach; + +/* Trigger TCP handshake which causes TCP_NEW_SYN_RECV state where +* is_fullsock == 0 and is_locked_tcp_sock == 0. +*/ + client_fd =connect_to_fd (server_fd,0 ); +if (!ASSERT_OK_FD (client_fd,"connect_to_fd" )) + goto close_server; + +close (client_fd); + +close_server: +close (server_fd); +detach: +bpf_prog_detach (cgroup_fd,BPF_CGROUP_SOCK_OPS ); +} + +void test_ns_sock_ops_get_sk (void ) +{ +struct sock_ops_get_sk *skel; +int cgroup_fd; + + cgroup_fd =test__join_cgroup ("/sock_ops_get_sk" ); +if (!ASSERT_OK_FD (cgroup_fd,"join_cgroup" )) +return ; + + skel =sock_ops_get_sk__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_open_load" )) + goto close_cgroup; + +/* Test SOCK_OPS_GET_SK with same src/dst register */ +if (test__start_subtest ("get_sk" )) { +run_sock_ops_test (cgroup_fd, +bpf_program__fd (skel->progs.sock_ops_get_sk_same_reg)); +ASSERT_EQ (skel->bss->null_seen,1 ,"null_seen" ); +ASSERT_EQ (skel->bss->bug_detected,0 ,"bug_not_detected" ); + } + +/* Test SOCK_OPS_GET_FIELD with same src/dst register */ +if (test__start_subtest ("get_field" )) { +run_sock_ops_test (cgroup_fd, +bpf_program__fd (skel->progs.sock_ops_get_field_same_reg)); +ASSERT_EQ (skel->bss->field_null_seen,1 ,"field_null_seen" ); +ASSERT_EQ (skel->bss->field_bug_detected,0 ,"field_bug_not_detected" ); + } + +/* Test SOCK_OPS_GET_SK with different src/dst register */ +if (test__start_subtest ("get_sk_diff_reg" )) { +run_sock_ops_test (cgroup_fd, +bpf_program__fd (skel->progs.sock_ops_get_sk_diff_reg)); +ASSERT_EQ (skel->bss->diff_reg_null_seen,1 ,"diff_reg_null_seen" ); +ASSERT_EQ (skel->bss->diff_reg_bug_detected,0 ,"diff_reg_bug_not_detected" ); + } + +sock_ops_get_sk__destroy (skel); +close_cgroup: +close (cgroup_fd); +}
tools/testing/selftests/bpf/progs/sock_ops_get_sk.c new file +117 -0
117 lines not on this page · raw message
Signature · 1 line
2.43.0
Quoted 4 lines · Jiayuan Chen
When a BPF
sock_opsprogram accesses ctx fields withdst_reg==src_reg, theSOCK_OPS_GET_SK()andSOCK_OPS_GET_FIELD()macros fail to zero the destination register in the !fullsock / !locked_tcp_sock path, leading to OOB read (GET_SK) and kernel pointer leak (GET_FIELD).
Jakub, can you help to push it to the net tree? Thanks!
This series was applied to netdev/net.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This series was applied to netdev/net.git (main)
by Jakub Kicinski <[email protected]>:
Quoted 11 lines · On Tue, 7 Apr 2026 10:26:26 +0800 you wrote:
When a BPF
sock_opsprogram accesses ctx fields withdst_reg==src_reg, theSOCK_OPS_GET_SK()andSOCK_OPS_GET_FIELD()macros fail to zero the destination register in the !fullsock / !locked_tcp_sock path, leading to OOB read (GET_SK) and kernel pointer leak (GET_FIELD).Patch 1: Fix both macros by adding
BPF_MOV64_IMM(si->dst_reg, 0)in the !fullsock landing pad.
Patch 2: Add selftests covering same-register and different-register cases for bothGET_SKandGET_FIELD.[...]
Here is the summary with links:
- [bpf,v3,1/2] bpf: Fix same-register dst/src OOB read and pointer leak in sock_ops
https://git.kernel.org/netdev/net/c/10f86a2a5c91 - [bpf,v3,2/2] selftests/bpf: Add tests for sock_ops ctx access with same src/dst register https://git.kernel.org/netdev/net/c/04013c3ca022
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html