sockmap fix for KASAN_VMALLOC and af_unix
Subsystems (7)
John Fastabend
maintainerv2 cover sockmap fix for KASAN_VMALLOC and af_unix
The af_unix tests in sockmap_listen causes a splat from KASAN_VMALLOC. Fix it here and include an extra test to catch case where both pairs of the af_unix socket are included in a BPF sockmap.
Also it seems the test infra is not passing type through correctly when testing unix_inet_redir_to_connected. Unfortunately, the simple fix also caused some CI tests to fail so investigating that now.
v2: drop changes to dgram side its fine per Jakub's point it graps a
reference on the peer socket from each sendmsg.
John Fastabend (2):
bpf: sockmap, af_unix stream sockets need to hold ref for pair sock
bpf: sockmap, add af_unix test with both sockets in map
include/linux/skmsg.h | 1 + include/net/af_unix.h | 1 + net/core/skmsg.c | 2 + net/unix/af_unix.c | 2 - net/unix/unix_bpf.c | 5 +++ .../selftests/bpf/prog_tests/sockmap_listen.c | 39 ++++++++++++++++--- .../selftests/bpf/progs/test_sockmap_listen.c | 7 ++++ 7 files changed, 49 insertions(+), 8 deletions(-)
Signature · 1 line
2.33.0
John Fastabend
maintainerPATCH v2 1/2 bpf: sockmap, af_unix stream sockets need to hold ref for pair sock
AF_UNIX stream sockets are a paired socket. So sending on one of the pairs will lookup the paired socket as part of the send operation. It is possible however to put just one of the pairs in a BPF map. This currently increments the refcnt on the sock in the sockmap to ensure it is not free'd by the stack before sockmap cleans up its state and stops any skbs being sent/recv'd to that socket.
But we missed a case. If the peer socket is closed it will be free'd by the stack. However, the paired socket can still be referenced from BPF sockmap side because we hold a reference there. Then if we are sending traffic through BPF sockmap to that socket it will try to dereference the free'd pair in its send logic creating a use after free. And following splat,
[59.900375] BUG: KASAN: slab-use-after-free in sk_wake_async+0x31/0x1b0 [59.901211] Read of size 8 at addr ffff88811acbf060 by task kworker/1:2/954 [...] [59.905468] Call Trace: [59.905787] <TASK> [59.906066] dump_stack_lvl+0x130/0x1d0 [59.908877] print_report+0x16f/0x740 [59.910629] kasan_report+0x118/0x160 [59.912576] sk_wake_async+0x31/0x1b0 [59.913554] sock_def_readable+0x156/0x2a0 [59.914060] unix_stream_sendmsg+0x3f9/0x12a0 [59.916398] sock_sendmsg+0x20e/0x250 [59.916854] skb_send_sock+0x236/0xac0 [59.920527] sk_psock_backlog+0x287/0xaa0
To fix let BPF sockmap hold a refcnt on both the socket in the sockmap and its paired socket. It wasn't obvious how to contain the fix to bpf_unix logic. The primarily problem with keeping this logic in bpf_unix was: In the sock close() we could handle the deref by having a close handler. But, when we are destroying the psock through a map delete operation we wouldn't have gotten any signal thorugh the proto struct other than it being replaced. If we do the deref from the proto replace its too early because we need to deref the skpair after the backlog worker has been stopped.
Given all this it seems best to just cache it at the end of the psock and eat 8B for the af_unix and vsock users.
Notice dgram sockets are OK because they handle locking already.
--- include/linux/skmsg.h | 1 + include/net/af_unix.h | 1 + net/core/skmsg.c | 2 ++ net/unix/af_unix.c | 2 -- net/unix/unix_bpf.c | 5 +++++ 5 files changed, 9 insertions(+), 2 deletions(-)
include/linux/skmsg.h +1 -0
@@ -106,6 +106,7 @@ struct sk_psock {struct mutex work_mutex;struct sk_psock_work_state work_state;struct delayed_work work; +struct sock *skpair;struct rcu_work rwork; };
include/net/af_unix.h +1 -0
@@ -75,6 +75,7 @@ struct unix_sock { };#define unix_sk (ptr) container_of_const(ptr, struct unix_sock, sk) +#define unix_peer (sk) (unix_sk(sk)->peer)#define peer_wait peer_wq.wait
net/core/skmsg.c +2 -0
@@ -826,6 +826,8 @@ static void sk_psock_destroy(struct work_struct *work)if (psock->sk_redir)sock_put (psock->sk_redir); +if (psock->skpair) +sock_put (psock->skpair);sock_put (psock->sk);kfree (psock); }
net/unix/af_unix.c +0 -2
@@ -212,8 +212,6 @@ static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb) }#endif /* CONFIG_SECURITY_NETWORK */ -#define unix_peer (sk) (unix_sk(sk)->peer) -static inline int unix_our_peer (struct sock *sk,struct sock *osk) {return unix_peer (osk) == sk;
net/unix/unix_bpf.c +5 -0
@@ -159,12 +159,17 @@ int unix_dgram_bpf_update_proto(struct sock *sk, struct sk_psock *psock, bool reint unix_stream_bpf_update_proto (struct sock *sk,struct sk_psock *psock,bool restore) { +struct sock *skpair =unix_peer (sk); +if (restore) { sk->sk_write_space = psock->saved_write_space;sock_replace_proto (sk, psock->sk_proto);return 0 ; } + skpair =unix_peer (sk); +sock_hold (skpair); + psock->skpair = skpair;unix_stream_bpf_check_needs_rebuild (psock->sk_proto);sock_replace_proto (sk, &unix_stream_bpf_prot);return 0 ;
Signature · 1 line
2.33.0
John Fastabend
maintainerPATCH v2 2/2 bpf: sockmap, add af_unix test with both sockets in map
In reply to John FastabendThis adds a test where both pairs of a af_unix paired socket are put into a BPF map. This ensures that when we tear down the af_unix pair we don't have any issues on sockmap side with ordering and reference counting.
--- .../selftests/bpf/prog_tests/sockmap_listen.c | 39 ++++++++++++++++--- .../selftests/bpf/progs/test_sockmap_listen.c | 7 ++++ 2 files changed, 40 insertions(+), 6 deletions(-)
tools/testing/selftests/bpf/prog_tests/sockmap_listen.c +33 -6
@@ -1824,8 +1824,10 @@ static void inet_unix_skb_redir_to_connected(struct test_sockmap_listen *skel,xbpf_prog_detach2 (verdict, sock_map,BPF_SK_SKB_VERDICT ); } -static void unix_inet_redir_to_connected (int family,int type,int sock_mapfd, -int verd_mapfd,enum redir_mode mode) +static void unix_inet_redir_to_connected (int family,int type, +int sock_mapfd,int nop_mapfd, +int verd_mapfd, +enum redir_mode mode) {const char *log_prefix =redir_mode_str (mode);int c0, c1, p0, p1;
@@ -1849,6 +1851,12 @@ static void unix_inet_redir_to_connected(int family, int type, int sock_mapfd,if (err) goto close; +if (nop_mapfd >=0 ) { + err =add_to_sockmap (nop_mapfd, c0, c1); +if (err) + goto close; + } + n =write (c1,"a" ,1 );if (n <0 )FAIL_ERRNO ("%s: write" , log_prefix);
@@ -1883,6 +1891,7 @@ static void unix_inet_skb_redir_to_connected(struct test_sockmap_listen *skel, struct bpf_map *inner_map, int family) { int verdict = bpf_program__fd(skel->progs.prog_skb_verdict); +int nop_map =bpf_map__fd (skel->maps.nop_map);int verdict_map =bpf_map__fd (skel->maps.verdict_map);int sock_map =bpf_map__fd (inner_map);int err;
@@ -1892,14 +1901,32 @@ static void unix_inet_skb_redir_to_connected(struct test_sockmap_listen *skel,return ; skel->bss->test_ingress = false; -unix_inet_redir_to_connected (family,SOCK_DGRAM , sock_map, verdict_map, +unix_inet_redir_to_connected (family,SOCK_DGRAM , + sock_map,-1 , verdict_map, +REDIR_EGRESS ); +unix_inet_redir_to_connected (family,SOCK_DGRAM , + sock_map,-1 , verdict_map,REDIR_EGRESS ); -unix_inet_redir_to_connected (family,SOCK_STREAM , sock_map, verdict_map, + +unix_inet_redir_to_connected (family,SOCK_DGRAM , + sock_map, nop_map, verdict_map, +REDIR_EGRESS ); +unix_inet_redir_to_connected (family,SOCK_STREAM , + sock_map, nop_map, verdict_map,REDIR_EGRESS ); skel->bss->test_ingress = true; -unix_inet_redir_to_connected (family,SOCK_DGRAM , sock_map, verdict_map, +unix_inet_redir_to_connected (family,SOCK_DGRAM , + sock_map,-1 , verdict_map, +REDIR_INGRESS ); +unix_inet_redir_to_connected (family,SOCK_STREAM , + sock_map,-1 , verdict_map, +REDIR_INGRESS ); + +unix_inet_redir_to_connected (family,SOCK_DGRAM , + sock_map, nop_map, verdict_map,REDIR_INGRESS ); -unix_inet_redir_to_connected (family,SOCK_STREAM , sock_map, verdict_map, +unix_inet_redir_to_connected (family,SOCK_STREAM , + sock_map, nop_map, verdict_map,REDIR_INGRESS );xbpf_prog_detach2 (verdict, sock_map,BPF_SK_SKB_VERDICT );
tools/testing/selftests/bpf/progs/test_sockmap_listen.c +7 -0
@@ -14,6 +14,13 @@ struct {__type (value, __u64); } sock_map SEC(".maps"); +struct { + __uint(type, BPF_MAP_TYPE_SOCKMAP); + __uint(max_entries, 2); + __type(key, __u32); + __type(value, __u64); +} nop_map SEC(".maps"); +struct { __uint(type, BPF_MAP_TYPE_SOCKHASH); __uint(max_entries, 2);
Signature · 1 line
2.33.0
Yonghong Song
reviewerRe: [PATCH bpf v2 1/2] bpf: sockmap, af_unix stream sockets need to hold ref for pair sock
In reply to John FastabendQuoted 110 lines · John Fastabend
AF_UNIXstream sockets are a paired socket. So sending on one of the pairs will lookup the paired socket as part of the send operation. It is possible however to put just one of the pairs in a BPF map. This currently increments the refcnt on the sock in the sockmap to ensure it is not free'd by the stack before sockmap cleans up its state and stops any skbs being sent/recv'd to that socket.But we missed a case. If the peer socket is closed it will be free'd by the stack. However, the paired socket can still be referenced from BPF sockmap side because we hold a reference there. Then if we are sending traffic through BPF sockmap to that socket it will try to dereference the free'd pair in its send logic creating a use after free. And following splat,
[59.900375] BUG: KASAN: slab-use-after-free in sk_wake_async+0x31/0x1b0 [59.901211] Read of size 8 at addr ffff88811acbf060 by task kworker/1:2/954 [...] [59.905468] Call Trace: [59.905787] <TASK> [59.906066] dump_stack_lvl+0x130/0x1d0 [59.908877] print_report+0x16f/0x740 [59.910629] kasan_report+0x118/0x160 [59.912576] sk_wake_async+0x31/0x1b0 [59.913554] sock_def_readable+0x156/0x2a0 [59.914060] unix_stream_sendmsg+0x3f9/0x12a0 [59.916398] sock_sendmsg+0x20e/0x250 [59.916854] skb_send_sock+0x236/0xac0 [59.920527] sk_psock_backlog+0x287/0xaa0To fix let BPF sockmap hold a refcnt on both the socket in the sockmap and its paired socket. It wasn't obvious how to contain the fix to
bpf_unixlogic. The primarily problem with keeping this logic inbpf_unixwas: In the sockclose()we could handle the deref by having a close handler. But, when we are destroying the psock through a map delete operation we wouldn't have gotten any signal thorugh the proto struct other than it being replaced. If we do the deref from the proto replace its too early because we need to deref the skpair after the backlog worker has been stopped.Given all this it seems best to just cache it at the end of the psock and eat 8B for the
af_unixand vsock users.Notice dgram sockets are OK because they handle locking already.
Fixes 94531cfcbe79 ("af_unix: Add unix_stream_proto for sockmap")Signed-off-by John Fastabend <[email protected]>--- include/linux/skmsg.h | 1 + include/net/af_unix.h | 1 + net/core/skmsg.c | 2 ++ net/unix/af_unix.c | 2 -- net/unix/unix_bpf.c | 5 +++++ 5 files changed, 9 insertions(+), 2 deletions(-)include/linux/skmsg.h +1
-0@@ -106,6 +106,7 @@ struct sk_psock {struct mutex work_mutex;struct sk_psock_work_state work_state;struct delayed_work work; +struct sock *skpair;struct rcu_work rwork; };include/net/af_unix.h +1
-0@@ -75,6 +75,7 @@ struct unix_sock { };#define unix_sk (ptr) container_of_const(ptr, struct unix_sock, sk) +#define unix_peer (sk) (unix_sk(sk)->peer)#define peer_wait peer_wq.waitnet/core/skmsg.c +2
-0@@ -826,6 +826,8 @@ static void sk_psock_destroy(struct work_struct *work)if (psock->sk_redir)sock_put (psock->sk_redir); +if (psock->skpair) +sock_put (psock->skpair);sock_put (psock->sk);kfree (psock); }net/unix/af_unix.c +0
-2@@ -212,8 +212,6 @@ static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb) }#endif /* CONFIG_SECURITY_NETWORK */ -#define unix_peer (sk) (unix_sk(sk)->peer) -static inline int unix_our_peer (struct sock *sk,struct sock *osk) {return unix_peer (osk) == sk;net/unix/unix_bpf.c +0
-0
net/unix/unix_bpf.c int unix_dgram_bpf_update_proto(struct sock *sk, struct sk_psock *psock, bool re · line 162
Quoted 4 lines
net/unix/unix_bpf.c +1
-0@@ -159,12 +159,17 @@ int unix_dgram_bpf_update_proto(struct sock *sk, struct sk_psock *psock, bool reint unix_stream_bpf_update_proto (struct sock *sk,struct sk_psock *psock,bool restore) { +struct sock *skpair =unix_peer (sk);
The above assignment is redundant.
Quoted 13 lines
net/unix/unix_bpf.c +4
-0+if (restore) { sk->sk_write_space = psock->saved_write_space;sock_replace_proto (sk, psock->sk_proto);return 0 ; } + skpair =unix_peer (sk); +sock_hold (skpair); + psock->skpair = skpair;unix_stream_bpf_check_needs_rebuild (psock->sk_proto);sock_replace_proto (sk, &unix_stream_bpf_prot);return 0 ;
Re: [PATCH bpf v2 1/2] bpf: sockmap, af_unix stream sockets need to hold ref for pair sock
In reply to John FastabendQuoted 7 lines · John Fastabend
AF_UNIXstream sockets are a paired socket. So sending on one of the pairs will lookup the paired socket as part of the send operation. It is possible however to put just one of the pairs in a BPF map. This currently increments the refcnt on the sock in the sockmap to ensure it is not free'd by the stack before sockmap cleans up its state and stops any skbs being sent/recv'd to that socket.
Quoted 6 lines
But we missed a case. If the peer socket is closed it will be free'd by the stack. However, the paired socket can still be referenced from BPF sockmap side because we hold a reference there. Then if we are sending traffic through BPF sockmap to that socket it will try to dereference the free'd pair in its send logic creating a use after free. And following splat,
Hmm, how could it pass the SOCK_DEAD test in unix_stream_sendmsg()?
2285 unix_state_lock(other);
2286
2287 if (sock_flag(other, SOCK_DEAD) ||
2288 (other->sk_shutdown & RCV_SHUTDOWN))
2289 goto pipe_err_free;
Thanks.
Jakub Sitnicki
maintainerRe: [PATCH bpf v2 1/2] bpf: sockmap, af_unix stream sockets need to hold ref for pair sock
Quoted 15 lines · Cong Wang
Quoted 7 lines · John Fastabend
AF_UNIXstream sockets are a paired socket. So sending on one of the pairs will lookup the paired socket as part of the send operation. It is possible however to put just one of the pairs in a BPF map. This currently increments the refcnt on the sock in the sockmap to ensure it is not free'd by the stack before sockmap cleans up its state and stops any skbs being sent/recv'd to that socket.Quoted 6 lines
But we missed a case. If the peer socket is closed it will be free'd by the stack. However, the paired socket can still be referenced from BPF sockmap side because we hold a reference there. Then if we are sending traffic through BPF sockmap to that socket it will try to dereference the free'd pair in its send logic creating a use after free. And following splat,
Quoted 7 lines
Hmm, how could it pass the
SOCK_DEADtest inunix_stream_sendmsg()?2285
unix_state_lock(other);
2286
2287 if (sock_flag(other, SOCK_DEAD)||
2288 (other->sk_shutdown&RCV_SHUTDOWN))
2289 gotopipe_err_free;
The quoted UAF happens after unix_state_unlock(other):
2285 unix_state_lock(other); 2286 2287 if (sock_flag(other, SOCK_DEAD) || 2288 (other->sk_shutdown & RCV_SHUTDOWN)) 2289 goto pipe_err_free; 2290 2291 maybe_add_creds(skb, sock, other); 2292 scm_stat_add(other, skb); 2293 skb_queue_tail(&other->sk_receive_queue, skb); 2294 unix_state_unlock(other); 2295 other->sk_data_ready(other); <-- UAF
Although, I think I saw it happen at unix_state_lock(other) as well.
We don't hold a ref on other, so we're racing with __sock_release / unix_release_sock.
Quoted 15 lines · John Fastabend
The
af_unixtests insockmap_listencauses a splat fromKASAN_VMALLOC. Fix it here and include an extra test to catch case where both pairs of theaf_unixsocket are included in a BPF sockmap.Also it seems the test infra is not passing type through correctly when testing
unix_inet_redir_to_connected. Unfortunately, the simple fix also caused some CI tests to fail so investigating that now.v2: drop changes to dgram side its fine per Jakub's point it graps a
reference on the peer socket from each sendmsg.John Fastabend (2):
bpf: sockmap,af_unixstream sockets need to hold ref for pair sock
bpf: sockmap, addaf_unixtest with both sockets in map
Quoted 8 lines
include/linux/skmsg.h | 1 + include/net/af_unix.h | 1 + net/core/skmsg.c | 2 + net/unix/af_unix.c | 2 - net/unix/unix_bpf.c | 5 +++ .../selftests/bpf/prog_tests/sockmap_listen.c | 39 ++++++++++++++++--- .../selftests/bpf/progs/test_sockmap_listen.c | 7 ++++ 7 files changed, 49 insertions(+), 8 deletions(-)
Short of the nit pointed out by Yonghong Song: