* [PATCH net 0/4] udp: Fix bind conflict check bypasses
@ 2026-11-20 17:43 Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 1/4] udp: Fix bind conflict check stopping at the first reuseport socket Juan Agustin Niccolini
` (3 more replies)
0 siblings, 4 replies; 5+ messages in thread
From: Juan Agustin Niccolini @ 2026-11-20 17:43 UTC (permalink / raw)
To: David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni
Cc: Simon Horman, Kuniyuki Iwashima, Willem de Bruijn,
Willem de Bruijn, Eric Garver, Shuah Khan, linux-kselftest,
netdev, linux-kernel
An unprivileged user can get a UDP socket bound to an address and port
that another user's socket holds, in a state bind() would have refused,
and receive that socket's datagrams. This series fixes three bugs that
allow that and adds a selftest.
These are sibling vulnerabilities of the TCP one fixed by my
commit f675070191f2 ("tcp: Fix the SO_REUSEPORT bind cache admitting a
conflicting socket"). The one in patch 1 has the same kind of cause: a
SO_REUSEPORT shortcut that lets one matching socket stand for every
socket on the port. The other two predate git. All were discovered
during an LLM-based audit.
Juan Agustin Niccolini (4):
udp: Fix bind conflict check stopping at the first reuseport socket
udp: Keep the bound device on disconnect unless connect() set it
udp: Ignore a connect()-set device in the bind conflict check
selftests: net: Add UDP bind conflict tests
include/net/sock.h | 4 +
net/core/sock.c | 3 +
net/ipv4/udp.c | 69 +++++-
net/ipv6/datagram.c | 25 +-
tools/testing/selftests/net/.gitignore | 1 +
tools/testing/selftests/net/Makefile | 1 +
.../testing/selftests/net/udp_bind_conflict.c | 228 ++++++++++++++++++
7 files changed, 317 insertions(+), 14 deletions(-)
base-commit: 19a227903e65c7a9c179156485660a4e017575fe
--
2.43.0
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH net 1/4] udp: Fix bind conflict check stopping at the first reuseport socket
2026-11-20 17:43 [PATCH net 0/4] udp: Fix bind conflict check bypasses Juan Agustin Niccolini
@ 2026-11-20 17:43 ` Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 2/4] udp: Keep the bound device on disconnect unless connect() set it Juan Agustin Niccolini
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Juan Agustin Niccolini @ 2026-11-20 17:43 UTC (permalink / raw)
To: David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni
Cc: Simon Horman, Kuniyuki Iwashima, Willem de Bruijn,
Willem de Bruijn, Eric Garver, Shuah Khan, linux-kselftest,
netdev, linux-kernel
Since commit df560056d960 ("udp: inuse checks can quit early for
reuseport"), udp_lib_lport_inuse() and udp_lib_lport_inuse2() report
the port as free as soon as they find one overlapping socket that has
SO_REUSEPORT and the same owner, without looking at the rest of the
chain.
This is only safe if overlap is transitive, and it is not:
- A wildcard address overlaps specific addresses that do not overlap
each other.
- A socket with no bound device overlaps sockets bound to different
devices.
As a result, an unprivileged user can bind an address and port that
another user's socket holds, and receive its datagrams:
victim: bind(127.0.0.2:P)
attacker: SO_REUSEPORT, bind(127.0.0.3:P)
attacker: SO_REUSEPORT, bind(0.0.0.0:P) /* should fail */
attacker: SO_REUSEPORT, bind(127.0.0.2:P) /* should fail */
Only stop at a socket that matches the new one in family, IPV6_V6ONLY,
bound device, SO_REUSEADDR and local address, and keep scanning past
the other compatible sockets. Identical SO_REUSEPORT sockets, the
workload the early stop was added for, still stop at the first one
(binding 16384 of them on a KASAN build: 223 ms before, 222 ms after,
3727 ms with the full scan every time).
Fixes: df560056d960 ("udp: inuse checks can quit early for reuseport")
Cc: stable@vger.kernel.org
Signed-off-by: Juan Agustin Niccolini <juanagusnicco@gmail.com>
---
net/ipv4/udp.c | 18 ++++++++++++++++--
1 file changed, 16 insertions(+), 2 deletions(-)
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 303d0102519a..446729b41d66 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -131,6 +131,15 @@ EXPORT_PER_CPU_SYMBOL_GPL(udp_memory_per_cpu_fw_alloc);
#define MAX_UDP_PORTS 65536
#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN_PERNET)
+static bool udp_lport_same_bind(const struct sock *sk, const struct sock *sk2)
+{
+ return sk2->sk_family == sk->sk_family &&
+ ipv6_only_sock(sk2) == ipv6_only_sock(sk) &&
+ sk2->sk_bound_dev_if == sk->sk_bound_dev_if &&
+ sk2->sk_reuse == sk->sk_reuse &&
+ inet_rcv_saddr_equal(sk, sk2, false);
+}
+
static int udp_lib_lport_inuse(struct net *net, __u16 num,
const struct udp_hslot *hslot,
unsigned long *bitmap,
@@ -154,8 +163,11 @@ static int udp_lib_lport_inuse(struct net *net, __u16 num,
if (!bitmap) {
if (sk2->sk_reuseport && sk->sk_reuseport &&
!rcu_access_pointer(sk->sk_reuseport_cb) &&
- uid_eq(uid, sk_uid(sk2)))
- return 0;
+ uid_eq(uid, sk_uid(sk2))) {
+ if (udp_lport_same_bind(sk, sk2))
+ return 0;
+ continue;
+ }
return 1;
}
__set_bit(udp_sk(sk2)->udp_port_hash >> log, bitmap);
@@ -188,6 +200,8 @@ static int udp_lib_lport_inuse2(struct net *net, __u16 num,
if (sk2->sk_reuseport && sk->sk_reuseport &&
!rcu_access_pointer(sk->sk_reuseport_cb) &&
uid_eq(uid, sk_uid(sk2))) {
+ if (!udp_lport_same_bind(sk, sk2))
+ continue;
res = 0;
} else {
res = 1;
--
2.43.0
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH net 2/4] udp: Keep the bound device on disconnect unless connect() set it
2026-11-20 17:43 [PATCH net 0/4] udp: Fix bind conflict check bypasses Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 1/4] udp: Fix bind conflict check stopping at the first reuseport socket Juan Agustin Niccolini
@ 2026-11-20 17:43 ` Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 3/4] udp: Ignore a connect()-set device in the bind conflict check Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 4/4] selftests: net: Add UDP bind conflict tests Juan Agustin Niccolini
3 siblings, 0 replies; 5+ messages in thread
From: Juan Agustin Niccolini @ 2026-11-20 17:43 UTC (permalink / raw)
To: David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni
Cc: Simon Horman, Kuniyuki Iwashima, Willem de Bruijn,
Willem de Bruijn, Eric Garver, Shuah Khan, linux-kselftest,
netdev, linux-kernel
__udp_disconnect() clears sk_bound_dev_if unconditionally, without a
bind conflict check.
This is only safe for a device that connect() set, which
__ip6_datagram_connect() does for a link-local or multicast peer. The
device can also come from:
- The user, with SO_BINDTODEVICE, SO_BINDTOIFINDEX or a bind() to a
scoped IPv6 address.
- A cgroup program, as with ip vrf exec.
The bind conflict checks treat sockets bound to different devices as
not overlapping. As a result, an unprivileged user can bind an address
and port that another user's socket holds on another device, clear its
own device, and receive the other socket's datagrams:
victim: SO_BINDTODEVICE(lo), bind(0.0.0.0:P)
attacker: SO_BINDTODEVICE(eth0), bind(127.0.0.1:P)
attacker: connect(AF_UNSPEC) /* clears the device */
Record in sk_userlocks that connect() set the device of a socket that
had none, and only clear the device on disconnect in that case.
SO_BINDTODEVICE and SO_BINDTOIFINDEX drop the record.
This changes connect(AF_UNSPEC) for UDP, ping, raw and L2TP sockets,
which all use __udp_disconnect(): a device that connect() did not set
is now kept, so changing it afterwards needs CAP_NET_RAW, as on a
socket that never disconnected.
Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2")
Cc: stable@vger.kernel.org
Signed-off-by: Juan Agustin Niccolini <juanagusnicco@gmail.com>
---
Notes:
- Within a VRF, connect() can replace the master with one of its
interfaces, which is now kept on disconnect, so binding back to the
master needs CAP_NET_RAW. Before, disconnect took the socket out of
its VRF. Restoring the master is not safe: the bind conflict checks
treat a master and its interfaces as different devices, so another
socket may hold the master by then. Fixing that is a separate,
VRF-wide change.
- Ping, raw and L2TP sockets call __udp_disconnect() without the socket
lock, so the sk_userlocks update is unlocked there. That predates
this change: commit 286c72deabaa ("udp: must lock the socket in
udp_disconnect()") only added the lock for UDP. Fixing it means
changing how ping, raw and L2TP handle disconnect, which is separate
from this fix, and a lost update cannot cause a bind overlap anyway.
include/net/sock.h | 4 ++++
net/core/sock.c | 1 +
net/ipv4/udp.c | 13 +++++++++----
net/ipv6/datagram.c | 17 +++++++++++++++--
4 files changed, 29 insertions(+), 6 deletions(-)
diff --git a/include/net/sock.h b/include/net/sock.h
index 173b37b2b8bb..78fc65adbcb8 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -1534,6 +1534,10 @@ static inline int __sk_prot_rehash(struct sock *sk)
* define SOCK_CONNECT_BIND - &sock->sk_userlocks flag for auto-bind at connect() time
*/
#define SOCK_CONNECT_BIND 16
+/**
+ * define SOCK_CONNECT_DEV - &sock->sk_userlocks flag for a connect()-set device
+ */
+#define SOCK_CONNECT_DEV 32
struct socket_alloc {
struct socket socket;
diff --git a/net/core/sock.c b/net/core/sock.c
index e2401d735c5a..5ce4aefc514d 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -650,6 +650,7 @@ static int sock_bindtoindex_locked(struct sock *sk, int ifindex)
/* Paired with all READ_ONCE() done locklessly. */
WRITE_ONCE(sk->sk_bound_dev_if, ifindex);
+ WRITE_ONCE(sk->sk_userlocks, sk->sk_userlocks & ~SOCK_CONNECT_DEV);
if (sk->sk_prot->rehash)
sk->sk_prot->rehash(sk);
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 446729b41d66..9f1f45afee53 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -2195,6 +2195,7 @@ static int udp_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
int __udp_disconnect(struct sock *sk, int flags)
{
+ u8 userlocks = READ_ONCE(sk->sk_userlocks);
struct inet_sock *inet = inet_sk(sk);
/*
* 1003.1g - break association.
@@ -2204,15 +2205,19 @@ int __udp_disconnect(struct sock *sk, int flags)
WRITE_ONCE(inet->inet_daddr, 0);
inet->inet_dport = 0;
sock_rps_reset_rxhash(sk);
- WRITE_ONCE(sk->sk_bound_dev_if, 0);
- if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) {
+ if (userlocks & SOCK_CONNECT_DEV) {
+ WRITE_ONCE(sk->sk_bound_dev_if, 0);
+ WRITE_ONCE(sk->sk_userlocks,
+ sk->sk_userlocks & ~SOCK_CONNECT_DEV);
+ }
+ if (!(userlocks & SOCK_BINDADDR_LOCK)) {
inet_reset_saddr(sk);
if (sk->sk_prot->rehash &&
- (sk->sk_userlocks & SOCK_BINDPORT_LOCK))
+ (userlocks & SOCK_BINDPORT_LOCK))
sk->sk_prot->rehash(sk);
}
- if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
+ if (!(userlocks & SOCK_BINDPORT_LOCK)) {
sk->sk_prot->unhash(sk);
inet->inet_sport = 0;
}
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index ff7a7ffbf983..0296207dbeb0 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -139,6 +139,14 @@ void ip6_datagram_release_cb(struct sock *sk)
}
EXPORT_SYMBOL_GPL(ip6_datagram_release_cb);
+static void ip6_datagram_connect_dev(struct sock *sk, int old_dif, int dif)
+{
+ if (!old_dif && dif)
+ WRITE_ONCE(sk->sk_userlocks,
+ sk->sk_userlocks | SOCK_CONNECT_DEV);
+ WRITE_ONCE(sk->sk_bound_dev_if, dif);
+}
+
int __ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
int addr_len)
{
@@ -229,11 +237,13 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
err = -EINVAL;
goto out;
}
- WRITE_ONCE(sk->sk_bound_dev_if, usin->sin6_scope_id);
+ ip6_datagram_connect_dev(sk, old_bound_dev_if,
+ usin->sin6_scope_id);
}
if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
- WRITE_ONCE(sk->sk_bound_dev_if, READ_ONCE(np->mcast_oif));
+ ip6_datagram_connect_dev(sk, old_bound_dev_if,
+ READ_ONCE(np->mcast_oif));
/* Connect to link-local address requires an interface */
if (!sk->sk_bound_dev_if) {
@@ -265,6 +275,9 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
np->flow_label = old_fl6_flowlabel;
inet->inet_dport = old_dport;
WRITE_ONCE(sk->sk_bound_dev_if, old_bound_dev_if);
+ if (!old_bound_dev_if)
+ WRITE_ONCE(sk->sk_userlocks,
+ sk->sk_userlocks & ~SOCK_CONNECT_DEV);
goto out;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH net 3/4] udp: Ignore a connect()-set device in the bind conflict check
2026-11-20 17:43 [PATCH net 0/4] udp: Fix bind conflict check bypasses Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 1/4] udp: Fix bind conflict check stopping at the first reuseport socket Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 2/4] udp: Keep the bound device on disconnect unless connect() set it Juan Agustin Niccolini
@ 2026-11-20 17:43 ` Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 4/4] selftests: net: Add UDP bind conflict tests Juan Agustin Niccolini
3 siblings, 0 replies; 5+ messages in thread
From: Juan Agustin Niccolini @ 2026-11-20 17:43 UTC (permalink / raw)
To: David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni
Cc: Simon Horman, Kuniyuki Iwashima, Willem de Bruijn,
Willem de Bruijn, Eric Garver, Shuah Khan, linux-kselftest,
netdev, linux-kernel
The bind conflict checks compare sk_bound_dev_if, which connect() also
writes, for a link-local or multicast IPv6 peer.
This is only safe if the device is the one that bind() reserved. A
socket bound with no device holds its port on every device, but while
it is connected to such a peer it looks bound to one device, so a bind
of the same port on another device is admitted.
As a result, an unprivileged user can bind a port that another user's
socket holds, and receive the datagrams that arrive on its device once
that socket disconnects:
victim: bind([::]:P), connect(fe80::1%eth0)
attacker: SO_BINDTODEVICE(eth1), bind([::]:P) /* should fail */
victim: connect(AF_UNSPEC)
Compare the device that bind() reserved instead: none for a socket
whose device connect() set, which SOCK_CONNECT_DEV records. A VRF
master that connect() narrowed to one of its interfaces does not get
the flag and is compared as before.
Note that the checks read the flag without the other socket's lock, so
it is ordered against the device with barriers: seeing the device
before the flag would trust a connect()-set device again.
Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2")
Cc: stable@vger.kernel.org
Signed-off-by: Juan Agustin Niccolini <juanagusnicco@gmail.com>
---
Notes:
- A connect() that sets the device and is undone again, both between
the two reads of the flag, can still be seen as a bound device, so a
conflicting bind can be admitted. Not fixed here because closing it
needs a sequence count in struct sock, a larger change for a window
that the other socket's owner has to open within two loads.
- connect() also narrows the local address of a wildcard-bound
socket, which opens the same window through the address. It is not
fixed here: connect() moves the socket to the secondary hash slot of
the narrowed address, so a specific-address bind on a busy port never
scans it. Closing that needs either a full scan on every bind or no
rehash on connect, which slows down binds or lookups on busy ports,
so I leave it for a separate patch.
net/core/sock.c | 2 ++
net/ipv4/udp.c | 46 +++++++++++++++++++++++++++++++++++----------
net/ipv6/datagram.c | 12 ++++++++++--
3 files changed, 48 insertions(+), 12 deletions(-)
diff --git a/net/core/sock.c b/net/core/sock.c
index 5ce4aefc514d..48ec344a3a8b 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -650,6 +650,8 @@ static int sock_bindtoindex_locked(struct sock *sk, int ifindex)
/* Paired with all READ_ONCE() done locklessly. */
WRITE_ONCE(sk->sk_bound_dev_if, ifindex);
+ /* Pairs with the first smp_rmb() in udp_bound_dev_if(). */
+ smp_wmb();
WRITE_ONCE(sk->sk_userlocks, sk->sk_userlocks & ~SOCK_CONNECT_DEV);
if (sk->sk_prot->rehash)
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 9f1f45afee53..a13bf32cbdb9 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -131,11 +131,35 @@ EXPORT_PER_CPU_SYMBOL_GPL(udp_memory_per_cpu_fw_alloc);
#define MAX_UDP_PORTS 65536
#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN_PERNET)
-static bool udp_lport_same_bind(const struct sock *sk, const struct sock *sk2)
+static int udp_bound_dev_if(const struct sock *sk)
+{
+ int dif;
+
+ if (READ_ONCE(sk->sk_userlocks) & SOCK_CONNECT_DEV)
+ return 0;
+ /* Pairs with the smp_wmb() before SOCK_CONNECT_DEV is cleared. */
+ smp_rmb();
+ dif = READ_ONCE(sk->sk_bound_dev_if);
+ /* Pairs with the smp_wmb() after SOCK_CONNECT_DEV is set. */
+ smp_rmb();
+ if (READ_ONCE(sk->sk_userlocks) & SOCK_CONNECT_DEV)
+ return 0;
+ return dif;
+}
+
+static bool udp_bound_dev_overlap(int dif, const struct sock *sk2)
+{
+ int dif2 = udp_bound_dev_if(sk2);
+
+ return !dif || !dif2 || dif == dif2;
+}
+
+static bool udp_lport_same_bind(const struct sock *sk, int dif,
+ const struct sock *sk2)
{
return sk2->sk_family == sk->sk_family &&
ipv6_only_sock(sk2) == ipv6_only_sock(sk) &&
- sk2->sk_bound_dev_if == sk->sk_bound_dev_if &&
+ udp_bound_dev_if(sk2) == dif &&
sk2->sk_reuse == sk->sk_reuse &&
inet_rcv_saddr_equal(sk, sk2, false);
}
@@ -145,6 +169,7 @@ static int udp_lib_lport_inuse(struct net *net, __u16 num,
unsigned long *bitmap,
struct sock *sk, unsigned int log)
{
+ int dif = udp_bound_dev_if(sk);
kuid_t uid = sk_uid(sk);
struct sock *sk2;
@@ -157,14 +182,13 @@ static int udp_lib_lport_inuse(struct net *net, __u16 num,
sk2 != sk &&
(bitmap || udp_sk(sk2)->udp_port_hash == num) &&
(bitmap || !sk2->sk_reuse || !sk->sk_reuse) &&
- (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
- sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
- inet_rcv_saddr_equal(sk, sk2, true)) {
+ inet_rcv_saddr_equal(sk, sk2, true) &&
+ udp_bound_dev_overlap(dif, sk2)) {
if (!bitmap) {
if (sk2->sk_reuseport && sk->sk_reuseport &&
!rcu_access_pointer(sk->sk_reuseport_cb) &&
uid_eq(uid, sk_uid(sk2))) {
- if (udp_lport_same_bind(sk, sk2))
+ if (udp_lport_same_bind(sk, dif, sk2))
return 0;
continue;
}
@@ -184,6 +208,7 @@ static int udp_lib_lport_inuse2(struct net *net, __u16 num,
struct udp_hslot *hslot2,
struct sock *sk)
{
+ int dif = udp_bound_dev_if(sk);
kuid_t uid = sk_uid(sk);
struct sock *sk2;
int res = 0;
@@ -194,13 +219,12 @@ static int udp_lib_lport_inuse2(struct net *net, __u16 num,
sk2 != sk &&
(udp_sk(sk2)->udp_port_hash == num) &&
(!sk2->sk_reuse || !sk->sk_reuse) &&
- (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
- sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
- inet_rcv_saddr_equal(sk, sk2, true)) {
+ inet_rcv_saddr_equal(sk, sk2, true) &&
+ udp_bound_dev_overlap(dif, sk2)) {
if (sk2->sk_reuseport && sk->sk_reuseport &&
!rcu_access_pointer(sk->sk_reuseport_cb) &&
uid_eq(uid, sk_uid(sk2))) {
- if (!udp_lport_same_bind(sk, sk2))
+ if (!udp_lport_same_bind(sk, dif, sk2))
continue;
res = 0;
} else {
@@ -2207,6 +2231,8 @@ int __udp_disconnect(struct sock *sk, int flags)
sock_rps_reset_rxhash(sk);
if (userlocks & SOCK_CONNECT_DEV) {
WRITE_ONCE(sk->sk_bound_dev_if, 0);
+ /* Pairs with the first smp_rmb() in udp_bound_dev_if(). */
+ smp_wmb();
WRITE_ONCE(sk->sk_userlocks,
sk->sk_userlocks & ~SOCK_CONNECT_DEV);
}
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index 0296207dbeb0..37a093f74724 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -141,9 +141,12 @@ EXPORT_SYMBOL_GPL(ip6_datagram_release_cb);
static void ip6_datagram_connect_dev(struct sock *sk, int old_dif, int dif)
{
- if (!old_dif && dif)
+ if (!old_dif && dif) {
WRITE_ONCE(sk->sk_userlocks,
sk->sk_userlocks | SOCK_CONNECT_DEV);
+ /* Pairs with the second smp_rmb() in udp_bound_dev_if(). */
+ smp_wmb();
+ }
WRITE_ONCE(sk->sk_bound_dev_if, dif);
}
@@ -275,9 +278,14 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
np->flow_label = old_fl6_flowlabel;
inet->inet_dport = old_dport;
WRITE_ONCE(sk->sk_bound_dev_if, old_bound_dev_if);
- if (!old_bound_dev_if)
+ if (!old_bound_dev_if) {
+ /* Pairs with the first smp_rmb() in
+ * udp_bound_dev_if().
+ */
+ smp_wmb();
WRITE_ONCE(sk->sk_userlocks,
sk->sk_userlocks & ~SOCK_CONNECT_DEV);
+ }
goto out;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH net 4/4] selftests: net: Add UDP bind conflict tests
2026-11-20 17:43 [PATCH net 0/4] udp: Fix bind conflict check bypasses Juan Agustin Niccolini
` (2 preceding siblings ...)
2026-11-20 17:43 ` [PATCH net 3/4] udp: Ignore a connect()-set device in the bind conflict check Juan Agustin Niccolini
@ 2026-11-20 17:43 ` Juan Agustin Niccolini
3 siblings, 0 replies; 5+ messages in thread
From: Juan Agustin Niccolini @ 2026-11-20 17:43 UTC (permalink / raw)
To: David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni
Cc: Simon Horman, Kuniyuki Iwashima, Willem de Bruijn,
Willem de Bruijn, Eric Garver, Shuah Khan, linux-kselftest,
netdev, linux-kernel
Add tests for the three bind conflict fixes in this series:
- reuseport_scan_{address,device,hash2}: a SO_REUSEPORT bind is refused
when a conflicting socket sits behind a compatible one, on the primary
and on the secondary hash.
- disconnect_keeps_{device,scoped_device}: connect(AF_UNSPEC) keeps a
device set with SO_BINDTOIFINDEX or with the scope id of bind().
- connect_device_ignored: a device set by connect() does not let a
socket on another device bind next to it.
reuseport_share and disconnect_clears_connect_device check that the
sharing and the clearing that should still happen still do.
Signed-off-by: Juan Agustin Niccolini <juanagusnicco@gmail.com>
---
tools/testing/selftests/net/.gitignore | 1 +
tools/testing/selftests/net/Makefile | 1 +
.../testing/selftests/net/udp_bind_conflict.c | 228 ++++++++++++++++++
3 files changed, 230 insertions(+)
create mode 100644 tools/testing/selftests/net/udp_bind_conflict.c
diff --git a/tools/testing/selftests/net/.gitignore b/tools/testing/selftests/net/.gitignore
index 21412510ac26..35f6d5220156 100644
--- a/tools/testing/selftests/net/.gitignore
+++ b/tools/testing/selftests/net/.gitignore
@@ -56,6 +56,7 @@ tools
tun
txring_overwrite
txtimestamp
+udp_bind_conflict
udp_splice_checksum
udpgso
udpgso_bench_rx
diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile
index 9180b9bec515..16b804559051 100644
--- a/tools/testing/selftests/net/Makefile
+++ b/tools/testing/selftests/net/Makefile
@@ -202,6 +202,7 @@ TEST_GEN_PROGS := \
tap \
tcp_port_share \
tls \
+ udp_bind_conflict \
udp_splice_checksum \
# end of TEST_GEN_PROGS
diff --git a/tools/testing/selftests/net/udp_bind_conflict.c b/tools/testing/selftests/net/udp_bind_conflict.c
new file mode 100644
index 000000000000..9a67f58c348a
--- /dev/null
+++ b/tools/testing/selftests/net/udp_bind_conflict.c
@@ -0,0 +1,228 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Check that bind() refuses a UDP socket that overlaps another one in
+ * the cases that SO_REUSEPORT, disconnect and connect() used to let
+ * through.
+ */
+
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <sched.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "kselftest_harness.h"
+
+#define PORT 34567
+#define MAX_FDS 32
+
+FIXTURE(udp_bind_conflict)
+{
+ int fd[MAX_FDS];
+ int nr_fds;
+ int lo;
+ int d0;
+};
+
+FIXTURE_SETUP(udp_bind_conflict)
+{
+ ASSERT_EQ(unshare(CLONE_NEWNET), 0);
+ ASSERT_EQ(system("ip link set dev lo up"), 0);
+ ASSERT_EQ(system("ip link add d0 type dummy"), 0);
+ ASSERT_EQ(system("ip link set dev d0 up"), 0);
+ ASSERT_EQ(system("ip addr add fe80::1/64 dev d0 nodad"), 0);
+
+ self->lo = if_nametoindex("lo");
+ self->d0 = if_nametoindex("d0");
+ ASSERT_NE(self->lo, 0);
+ ASSERT_NE(self->d0, 0);
+ self->nr_fds = 0;
+}
+
+FIXTURE_TEARDOWN(udp_bind_conflict)
+{
+ while (self->nr_fds)
+ close(self->fd[--self->nr_fds]);
+}
+
+/* Bind a UDP socket to addr:PORT, on device @ifindex if not 0: through
+ * the scope id for a link-local address, SO_BINDTOIFINDEX otherwise.
+ * Returns the socket, or -errno.
+ */
+static int udp_bind(FIXTURE_DATA(udp_bind_conflict) *self, const char *addr,
+ int ifindex, bool reuseport)
+{
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in v4;
+ struct sockaddr_in6 v6;
+ } sa = {};
+ socklen_t len;
+ int one = 1;
+ int fd, err;
+
+ if (self->nr_fds == MAX_FDS)
+ return -ENOSPC;
+
+ if (inet_pton(AF_INET, addr, &sa.v4.sin_addr) == 1) {
+ sa.v4.sin_family = AF_INET;
+ sa.v4.sin_port = htons(PORT);
+ len = sizeof(sa.v4);
+ } else if (inet_pton(AF_INET6, addr, &sa.v6.sin6_addr) == 1) {
+ sa.v6.sin6_family = AF_INET6;
+ sa.v6.sin6_port = htons(PORT);
+ len = sizeof(sa.v6);
+ if (IN6_IS_ADDR_LINKLOCAL(&sa.v6.sin6_addr)) {
+ sa.v6.sin6_scope_id = ifindex;
+ ifindex = 0;
+ }
+ } else {
+ return -EINVAL;
+ }
+
+ fd = socket(sa.sa.sa_family, SOCK_DGRAM, 0);
+ if (fd < 0)
+ return -errno;
+
+ if ((reuseport &&
+ setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) ||
+ (ifindex &&
+ setsockopt(fd, SOL_SOCKET, SO_BINDTOIFINDEX,
+ &ifindex, sizeof(ifindex))) ||
+ bind(fd, &sa.sa, len)) {
+ err = -errno;
+ close(fd);
+ return err;
+ }
+
+ self->fd[self->nr_fds++] = fd;
+ return fd;
+}
+
+static int disconnect(int fd)
+{
+ struct sockaddr sa = { .sa_family = AF_UNSPEC };
+
+ return connect(fd, &sa, sizeof(sa));
+}
+
+/* connect() to a link-local peer, which sets the device to @ifindex */
+static int connect_link_local(int fd, int ifindex)
+{
+ struct sockaddr_in6 sa = {
+ .sin6_family = AF_INET6,
+ .sin6_port = htons(PORT),
+ .sin6_scope_id = ifindex,
+ };
+
+ inet_pton(AF_INET6, "fe80::2", &sa.sin6_addr);
+ return connect(fd, (struct sockaddr *)&sa, sizeof(sa));
+}
+
+static int bound_ifindex(int fd)
+{
+ socklen_t len = sizeof(int);
+ int ifindex;
+
+ if (getsockopt(fd, SOL_SOCKET, SO_BINDTOIFINDEX, &ifindex, &len))
+ return -errno;
+ return ifindex;
+}
+
+/* The conflict scan used to stop at the first SO_REUSEPORT socket of the
+ * same owner that overlapped the new one, before reaching 127.0.0.2.
+ */
+TEST_F(udp_bind_conflict, reuseport_scan_address)
+{
+ ASSERT_LE(0, udp_bind(self, "127.0.0.2", 0, false));
+ ASSERT_LE(0, udp_bind(self, "127.0.0.3", 0, true));
+ ASSERT_EQ(-EADDRINUSE, udp_bind(self, "0.0.0.0", 0, true));
+}
+
+TEST_F(udp_bind_conflict, reuseport_scan_device)
+{
+ ASSERT_LE(0, udp_bind(self, "0.0.0.0", self->lo, false));
+ ASSERT_LE(0, udp_bind(self, "0.0.0.0", self->d0, true));
+ ASSERT_EQ(-EADDRINUSE, udp_bind(self, "0.0.0.0", 0, true));
+}
+
+/* More than 10 sockets on the port: the secondary hash is scanned. */
+TEST_F(udp_bind_conflict, reuseport_scan_hash2)
+{
+ char addr[INET_ADDRSTRLEN];
+ int i;
+
+ ASSERT_LE(0, udp_bind(self, "127.0.0.2", self->lo, false));
+ for (i = 3; i < 14; i++) {
+ snprintf(addr, sizeof(addr), "127.0.0.%d", i);
+ ASSERT_LE(0, udp_bind(self, addr, 0, true));
+ }
+ ASSERT_LE(0, udp_bind(self, "127.0.0.2", self->d0, true));
+ ASSERT_EQ(-EADDRINUSE, udp_bind(self, "127.0.0.2", 0, true));
+}
+
+/* Sockets of one owner that SO_REUSEPORT lets share a port still can. */
+TEST_F(udp_bind_conflict, reuseport_share)
+{
+ int i;
+
+ for (i = 0; i < 16; i++)
+ ASSERT_LE(0, udp_bind(self, "127.0.0.1", 0, true));
+ ASSERT_LE(0, udp_bind(self, "0.0.0.0", 0, true));
+ ASSERT_LE(0, udp_bind(self, "0.0.0.0", self->lo, true));
+ ASSERT_LE(0, udp_bind(self, "127.0.0.1", self->d0, true));
+}
+
+/* Disconnect used to clear the device the socket was bound to, leaving it
+ * on top of 0.0.0.0%lo where bind() had refused it.
+ */
+TEST_F(udp_bind_conflict, disconnect_keeps_device)
+{
+ int fd;
+
+ ASSERT_LE(0, udp_bind(self, "0.0.0.0", self->lo, false));
+ ASSERT_EQ(-EADDRINUSE, udp_bind(self, "127.0.0.1", 0, false));
+
+ fd = udp_bind(self, "127.0.0.1", self->d0, false);
+ ASSERT_LE(0, fd);
+ ASSERT_EQ(0, disconnect(fd));
+ ASSERT_EQ(self->d0, bound_ifindex(fd));
+}
+
+TEST_F(udp_bind_conflict, disconnect_keeps_scoped_device)
+{
+ int fd;
+
+ fd = udp_bind(self, "fe80::1", self->d0, false);
+ ASSERT_LE(0, fd);
+ ASSERT_EQ(0, disconnect(fd));
+ ASSERT_EQ(self->d0, bound_ifindex(fd));
+}
+
+/* A device that connect() set is still cleared by disconnect. */
+TEST_F(udp_bind_conflict, disconnect_clears_connect_device)
+{
+ int fd;
+
+ fd = udp_bind(self, "::", 0, false);
+ ASSERT_LE(0, fd);
+ ASSERT_EQ(0, connect_link_local(fd, self->d0));
+ ASSERT_EQ(self->d0, bound_ifindex(fd));
+ ASSERT_EQ(0, disconnect(fd));
+ ASSERT_EQ(0, bound_ifindex(fd));
+}
+
+/* A device that connect() set used to count in the conflict check, so a
+ * socket on another device could bind next to [::]:PORT and overlap it
+ * once it disconnected.
+ */
+TEST_F(udp_bind_conflict, connect_device_ignored)
+{
+ int fd;
+
+ fd = udp_bind(self, "::", 0, false);
+ ASSERT_LE(0, fd);
+ ASSERT_EQ(0, connect_link_local(fd, self->d0));
+ ASSERT_EQ(-EADDRINUSE, udp_bind(self, "::", self->lo, false));
+}
+
+TEST_HARNESS_MAIN
--
2.43.0
^ permalink raw reply related [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-20 17:43 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20 17:43 [PATCH net 0/4] udp: Fix bind conflict check bypasses Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 1/4] udp: Fix bind conflict check stopping at the first reuseport socket Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 2/4] udp: Keep the bound device on disconnect unless connect() set it Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 3/4] udp: Ignore a connect()-set device in the bind conflict check Juan Agustin Niccolini
2026-11-20 17:43 ` [PATCH net 4/4] selftests: net: Add UDP bind conflict tests Juan Agustin Niccolini
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox