ovpn: assorted net fixes
Subsystems (2)
v3 cover ovpn: assorted net fixes
From: Antonio Quartulli <[email protected]>
Hi all,
This is v3 of the collected ovpn fixes for net, sent here for review (and sashiko pre-review) before submission to netdev as a pull request.
Changes since v2:
* dropped "ovpn: tcp - fix peer reference leak on deferred deletion" (v2 5/9): the deferred-deletion reference is already taken before scheduling the work in the current tree, so the patch is no longer needed (the v2 version also introduced a TOCTOU race)
* added "ovpn: invalidate the UDP TX dst_cache when the flow key changes"
* "ovpn: rehash peer in by_transp_addr table on CMD_PEER_SET":
restored the peer->ovpn->lock and peer->lock acquisitions that the __ovpn_peer_hash_transp_addr() refactor had accidentally dropped from ovpn_peer_endpoints_update(); without them an MP float hit a lockdep splat and a double unlock (panic)
* "ovpn: disable IPv4 redirects on MP interfaces": moved the SEND_REDIRECTS handling to ndo_open() so it is re-applied on every bring-up and survives the IPv4 in_device being recreated (e.g. after moving the interface to another netns)
Thanks,
Antonio
Antonio Quartulli (9):
ovpn: skip rehash for peers already removed from by_id
ovpn: rehash peer in by_transp_addr table on CMD_PEER_SET
ovpn: fix data race reading cached local endpoint on TX path
ovpn: ensure socket is owned by ovpn before deref sk_user_data
ovpn: zero-initialize sockaddr before learning a floated endpoint
ovpn: hash floated peer by transport identity only
ovpn: disable IPv4 redirects on MP interfaces
ovpn: ensure TCP vars are initialized first
ovpn: invalidate the UDP TX dst_cache when the flow key changes
drivers/net/ovpn/main.c | 60 +++++++++---- drivers/net/ovpn/netlink.c | 19 ++++- drivers/net/ovpn/peer.c | 167 +++++++++++++++++++++++++++++-------- drivers/net/ovpn/peer.h | 15 ++++ drivers/net/ovpn/socket.c | 9 ++ drivers/net/ovpn/udp.c | 87 +++++++++++++++---- 6 files changed, 286 insertions(+), 71 deletions(-)
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 2/9 ovpn: rehash peer in by_transp_addr table on CMD_PEER_SET
From: Antonio Quartulli <[email protected]>
When userspace updates a peer's remote endpoint via OVPN_CMD_PEER_SET, ovpn_nl_peer_modify() installs a new ovpn_bind through ovpn_peer_reset_sockaddr(), but ovpn_nl_peer_set_doit() only calls ovpn_peer_hash_vpn_ip() to refresh the VPN-IP hashtables. The peer is left in the bucket of peers->by_transp_addr corresponding to its old remote address.
As a consequence, datagrams arriving at the UDP RX path from the newly configured remote hash to a different slot and the lockless lookup in ovpn_peer_get_by_transp_addr() (called from ovpn_udp_encap_recv()) does not find the peer, until either a float event or a peer re-add fixes the bucket.
Introduce ovpn_peer_hash_transp_addr() (modeled after ovpn_peer_hash_vpn_ip()) and invoke it from ovpn_nl_peer_set_doit() whenever the request carried a new remote address. The helper bails out in P2P mode and on peers without a bind (TCP), and relies on hlist_nulls_del_init_rcu()'s pprev==NULL short-circuit to handle the case of an entry not currently linked in the table.
--- drivers/net/ovpn/netlink.c | 6 +++ drivers/net/ovpn/peer.c | 105 +++++++++++++++++++++++++------------ drivers/net/ovpn/peer.h | 1 + 3 files changed, 79 insertions(+), 33 deletions(-)
drivers/net/ovpn/netlink.c +6 -0
@@ -534,6 +534,12 @@ int ovpn_nl_peer_set_doit(struct sk_buff *skb, struct genl_info *info)*/ if (ret >0 )ovpn_peer_hash_vpn_ip (peer); +/* if the remote endpoint was updated, the by_transp_addr hash bucket +* also needs to be refreshed, otherwise incoming packets from the new +* remote address would fail the lockless lookup +*/ +if (attrs[OVPN_A_PEER_REMOTE_IPV4 ] || attrs[OVPN_A_PEER_REMOTE_IPV6 ]) +ovpn_peer_hash_transp_addr (peer);spin_unlock_bh (&ovpn->lock);ovpn_peer_put (peer);
drivers/net/ovpn/peer.c +72 -33
137 lines not on this page · raw message
drivers/net/ovpn/peer.h +1 -0
@@ -150,6 +150,7 @@ struct ovpn_peer *ovpn_peer_get_by_id(struct ovpn_priv *ovpn, u32 peer_id);struct ovpn_peer *ovpn_peer_get_by_dst (struct ovpn_priv *ovpn,struct sk_buff *skb);void ovpn_peer_hash_vpn_ip (struct ovpn_peer *peer); +void ovpn_peer_hash_transp_addr (struct ovpn_peer *peer);bool ovpn_peer_check_by_src (struct ovpn_priv *ovpn,struct sk_buff *skb,struct ovpn_peer *peer);
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 3/9 ovpn: fix data race reading cached local endpoint on TX path
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
The cached local source address bind->local is updated in place on a live, RCU-published ovpn_bind while holding peer->lock: the UDP output error paths reset it (ovpn_udp4_output()/ovpn_udp6_output()) and the RX float path learns it (ovpn_peer_endpoints_update()). The UDP TX fast path and the netlink dump, however, read bind->local holding only rcu_read_lock(), never peer->lock.
For bind->local.ipv6 this is a torn read: struct in6_addr is 128 bit and is copied as multiple words, so a concurrent in-place update can make a reader observe a mix of the old and new address. The mangled source address then feeds ip6_dst_lookup_flow() and udp_tunnel6_xmit_skb(). For bind->local.ipv4 (a single aligned word) it is a data race without tearing.
A spinlock on the per-packet TX path is not acceptable, and READ_ONCE()/WRITE_ONCE() cannot atomically access the 128-bit IPv6 address (the >8-byte access is rejected at build time and per-word accesses still can't yield a consistent snapshot).
Serialize the IPv6 field with a per-peer seqcount_spinlock_t tied to the existing peer->lock: the in-place writers (already under peer->lock) bump it, and readers take a lock-free read_seqcount_begin()/retry() snapshot via the new ovpn_peer_local_ipv6() helper. The single-word IPv4 field is handled with plain READ_ONCE()/WRITE_ONCE(). bind->remote is untouched:
it is immutable for a given bind object (only swapped via whole-bind RCU replacement), so reading it locklessly remains safe.
--- drivers/net/ovpn/netlink.c | 13 +++++++++++-- drivers/net/ovpn/peer.c | 26 +++++++++++++++++++++++++- drivers/net/ovpn/peer.h | 6 ++++++ drivers/net/ovpn/udp.c | 17 +++++++++++++---- 4 files changed, 55 insertions(+), 7 deletions(-)
drivers/net/ovpn/netlink.c +11 -2
@@ -610,14 +610,23 @@ static int ovpn_nl_send_peer(struct sk_buff *skb, const struct genl_info *info, bind = rcu_dereference(peer->bind); if (bind) { if (bind->remote.in4.sin_family == AF_INET) { + /* bind->local is updated in place under peer->lock; + * READ_ONCE() pairs with the WRITE_ONCE() updaters + */ if (nla_put_in_addr(skb, OVPN_A_PEER_REMOTE_IPV4, bind->remote.in4.sin_addr.s_addr) || nla_put_net16(skb, OVPN_A_PEER_REMOTE_PORT, bind->remote.in4.sin_port) || nla_put_in_addr(skb, OVPN_A_PEER_LOCAL_IPV4, - bind->local.ipv4.s_addr)) + READ_ONCE(bind->local.ipv4.s_addr))) goto err_unlock; } else if (bind->remote.in4.sin_family == AF_INET6) { + struct in6_addr local_ipv6; + + /* read the 128-bit local address under the peer + * seqcount to avoid a torn read + */ + ovpn_peer_local_ipv6(peer, bind, &local_ipv6); if (nla_put_in6_addr(skb, OVPN_A_PEER_REMOTE_IPV6, &bind->remote.in6.sin6_addr) || nla_put_u32(skb, OVPN_A_PEER_REMOTE_IPV6_SCOPE_ID,
@@ -625,7 +634,7 @@ static int ovpn_nl_send_peer(struct sk_buff *skb, const struct genl_info *info,nla_put_net16 (skb,OVPN_A_PEER_REMOTE_PORT , bind->remote.in6.sin6_port) ||nla_put_in6_addr (skb,OVPN_A_PEER_LOCAL_IPV6 , - &bind->local.ipv6)) + &local_ipv6)) goto err_unlock; } }
drivers/net/ovpn/peer.c +25 -1
@@ -113,6 +113,7 @@ struct ovpn_peer *ovpn_peer_new(struct ovpn_priv *ovpn, u32 id)RCU_INIT_POINTER (peer->bind,NULL );ovpn_crypto_state_init (&peer->crypto);spin_lock_init (&peer->lock); +seqcount_spinlock_init (&peer->bind_local_seq, &peer->lock);kref_init (&peer->refcount);ovpn_peer_stats_init (&peer->vpn_stats);ovpn_peer_stats_init (&peer->link_stats);
@@ -176,6 +177,27 @@ int ovpn_peer_reset_sockaddr(struct ovpn_peer *peer,return 0 ; } +/** +* ovpn_peer_local_ipv6 - read the cached local IPv6 endpoint of a peer +* @peer: the peer owning the binding +* @bind: the binding to read the local address from +* @dst: where the local IPv6 address is copied to +* +* bind->local is updated in place under peer->lock (TX error path and RX +* float path). Read the 128-bit address under the peer seqcount so that +* lockless readers never observe a torn value. +*/ +void ovpn_peer_local_ipv6 (const struct ovpn_peer *peer, +const struct ovpn_bind *bind,struct in6_addr *dst) +{ +unsigned int seq; + +do { + seq =read_seqcount_begin (&peer->bind_local_seq); + *dst = bind->local.ipv6; + }while (read_seqcount_retry (&peer->bind_local_seq, seq)); +} +/* variable name __tbl2 needs to be different from __tbl1 * in the macro below to avoid confusing clang */
@@ -238,7 +260,7 @@ void ovpn_peer_endpoints_update(struct ovpn_peer *peer, struct sk_buff *skb)netdev_name (peer->ovpn->dev), peer->id, &bind->local.ipv4.s_addr, &ip_hdr(skb)->daddr); - bind->local.ipv4.s_addr =ip_hdr (skb)->daddr; +WRITE_ONCE (bind->local.ipv4.s_addr,ip_hdr (skb)->daddr); reset_cache = true; }break ;
@@ -269,7 +291,9 @@ void ovpn_peer_endpoints_update(struct ovpn_peer *peer, struct sk_buff *skb)netdev_name (peer->ovpn->dev), peer->id, &bind->local.ipv6, &ipv6_hdr(skb)->daddr); +write_seqcount_begin (&peer->bind_local_seq); bind->local.ipv6 =ipv6_hdr (skb)->daddr; +write_seqcount_end (&peer->bind_local_seq); reset_cache = true; }break ;
drivers/net/ovpn/peer.h +6 -0
@@ -10,6 +10,7 @@#ifndef _NET_OVPN_OVPNPEER_H_#define _NET_OVPN_OVPNPEER_H_ +#include <linux/seqlock.h> #include <net/dst_cache.h> #include <net/strparser.h>
@@ -56,6 +57,8 @@* @link_stats: per-peer link/transport TX/RX stats * @delete_reason: why peer was deleted (i.e. timeout, transport error, ..) * @lock: protects binding to peer (bind) and keepalive* fields +* @bind_local_seq: seqcount serializing in-place updates of bind->local +* (done under @lock) against lockless readers on the TX path * @refcount: reference counter * @rcu: used to free peer in an RCU safe way * @release_entry: entry for the socket release list
@@ -110,6 +113,7 @@ struct ovpn_peer {struct ovpn_peer_stats link_stats;enum ovpn_del_peer_reason delete_reason;spinlock_t lock;/* protects bind and keepalive* */ +seqcount_spinlock_t bind_local_seq;/* protects bind->local */ struct kref refcount;struct rcu_head rcu;struct llist_node release_entry;
@@ -151,6 +155,8 @@ struct ovpn_peer *ovpn_peer_get_by_dst(struct ovpn_priv *ovpn, struct sk_buff *skb);void ovpn_peer_hash_vpn_ip (struct ovpn_peer *peer);void ovpn_peer_hash_transp_addr (struct ovpn_peer *peer); +void ovpn_peer_local_ipv6 (const struct ovpn_peer *peer, +const struct ovpn_bind *bind,struct in6_addr *dst);bool ovpn_peer_check_by_src (struct ovpn_priv *ovpn,struct sk_buff *skb,struct ovpn_peer *peer);
drivers/net/ovpn/udp.c +13 -4
@@ -147,7 +147,10 @@ static int ovpn_udp4_output(struct ovpn_peer *peer, struct ovpn_bind *bind, {struct rtable *rt;struct flowi4 fl = { - .saddr = bind->local.ipv4.s_addr, +/* bind->local is updated in place under peer->lock; a single +* aligned word is read/written atomically via {READ,WRITE}_ONCE +*/ + .saddr =READ_ONCE (bind->local.ipv4.s_addr), .daddr = bind->remote.in4.sin_addr.s_addr, .fl4_sport =inet_sk (sk)->inet_sport, .fl4_dport = bind->remote.in4.sin_port,
@@ -169,7 +172,7 @@ static int ovpn_udp4_output(struct ovpn_peer *peer, struct ovpn_bind *bind,*/ fl.saddr =0 ;spin_lock_bh (&peer->lock); - bind->local.ipv4.s_addr =0 ; +WRITE_ONCE (bind->local.ipv4.s_addr,0 );spin_unlock_bh (&peer->lock);dst_cache_reset (cache); }
@@ -178,7 +181,7 @@ static int ovpn_udp4_output(struct ovpn_peer *peer, struct ovpn_bind *bind,if (IS_ERR (rt) &&PTR_ERR (rt) == -EINVAL ) { fl.saddr =0 ;spin_lock_bh (&peer->lock); - bind->local.ipv4.s_addr =0 ; +WRITE_ONCE (bind->local.ipv4.s_addr,0 );spin_unlock_bh (&peer->lock);dst_cache_reset (cache);
@@ -224,7 +227,6 @@ static int ovpn_udp6_output(struct ovpn_peer *peer, struct ovpn_bind *bind,int ret;struct flowi6 fl = { - .saddr = bind->local.ipv6, .daddr = bind->remote.in6.sin6_addr, .fl6_sport =inet_sk (sk)->inet_sport, .fl6_dport = bind->remote.in6.sin6_port,
@@ -233,6 +235,11 @@ static int ovpn_udp6_output(struct ovpn_peer *peer, struct ovpn_bind *bind, .flowi6_oif = bind->remote.in6.sin6_scope_id, }; +/* bind->local is updated in place under peer->lock; read the 128-bit +* address under the peer seqcount to avoid a torn read +*/ +ovpn_peer_local_ipv6 (peer, bind, &fl.saddr); +local_bh_disable (); dst =dst_cache_get_ip6 (cache, &fl.saddr);if (dst)
@@ -245,7 +252,9 @@ static int ovpn_udp6_output(struct ovpn_peer *peer, struct ovpn_bind *bind,*/ fl.saddr = in6addr_any;spin_lock_bh (&peer->lock); +write_seqcount_begin (&peer->bind_local_seq); bind->local.ipv6 = in6addr_any; +write_seqcount_end (&peer->bind_local_seq);spin_unlock_bh (&peer->lock);dst_cache_reset (cache); }
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 4/9 ovpn: ensure socket is owned by ovpn before deref sk_user_data
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
Some subsystems, like BPF SOCKMAP, set sk_user_data without actually setting the encap_type.
For this reason, we must make sure that the type is the one ovpn expects before dereferencing sk_user_data.
Failing to do so may lead to out-of-bounds reads.
--- drivers/net/ovpn/socket.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/net/ovpn/socket.c +9 -0
@@ -162,6 +162,15 @@ struct ovpn_socket *ovpn_socket_new(struct socket *sock, struct ovpn_peer *peer)rcu_read_lock (); ovpn_sock =rcu_dereference_sk_user_data (sk);if (ovpn_sock) { +/* something else filled the sk_user_data without +* setting the encap_type. Reject the socket. +*/ +if (!type) { + ovpn_sock =ERR_PTR (-EBUSY ); +rcu_read_unlock (); + goto sock_release; + } +/* socket owned by another ovpn instance, we can't use it */ if (ovpn_sock->ovpn != peer->ovpn) { ovpn_sock =ERR_PTR (-EBUSY );
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 1/9 ovpn: skip rehash for peers already removed from by_id
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
ovpn_nl_peer_set_doit() resolves the target peer via ovpn_peer_get_by_id() before taking ovpn->lock. In the window between the lookup (which only takes a refcount) and the subsequent spin_lock_bh(&ovpn->lock), a concurrent OVPN_CMD_PEER_DEL, keepalive expiry, or socket teardown can take ovpn->lock first, run ovpn_peer_remove() to unhash the peer from all four tables (by_id, by_vpn_addr4/6, by_transp_addr) and release the lock. set_doit then acquires ovpn->lock and calls ovpn_peer_hash_vpn_ip(), which re-inserts the now-removed peer back into the rehashing tables.
The same race affects the float path: ovpn_peer_endpoints_update() holds only a refcount and acquires ovpn->lock very late (after async AEAD decrypt and a netlink notification), then rehashes the peer in the by_transp_addr table.
The resurrected peer becomes reachable again from the RX lookup (ovpn_peer_get_by_transp_addr) and the TX VPN-IP lookup, even though userspace believes it is gone. Once the data-path refcount drops the peer is freed via call_rcu while the hash entries embedded in it remain linked, opening a UAF window.
Bail out of the rehash when hash_entry_id is unhashed, mirroring the sentinel already used by ovpn_peer_remove() to detect the already-removed state. The check is safe under ovpn->lock, which serializes every mutation of hash_entry_id, and is a no-op for the add path because ovpn_peer_add_mp() inserts hash_entry_id before calling ovpn_peer_hash_vpn_ip().
---
Changes since v1:
* simplified flow in ovpn_peer_endpoints_update() and introduced new unlock2 label
--- drivers/net/ovpn/peer.c | 73 ++++++++++++++++++++++++----------------- 1 file changed, 43 insertions(+), 30 deletions(-)
drivers/net/ovpn/peer.c +43 -30
@@ -297,40 +297,46 @@ void ovpn_peer_endpoints_update(struct ovpn_peer *peer, struct sk_buff *skb)/* rehashing is required only in MP mode as P2P has one peer * only and thus there is no hashtable */ -if (peer->ovpn->mode ==OVPN_MODE_MP ) { -spin_lock_bh (&peer->ovpn->lock); -spin_lock_bh (&peer->lock); - bind =rcu_dereference_protected (peer->bind, -lockdep_is_held (&peer->lock)); -if (unlikely (!bind)) { -spin_unlock_bh (&peer->lock); -spin_unlock_bh (&peer->ovpn->lock); -return ; - } +if (peer->ovpn->mode !=OVPN_MODE_MP ) +return ; -/* This function may be invoked concurrently, therefore another -* float may have happened in parallel: perform rehashing -* using the peer->bind->remote directly as key -*/ +spin_lock_bh (&peer->ovpn->lock); +spin_lock_bh (&peer->lock); + bind =rcu_dereference_protected (peer->bind, +lockdep_is_held (&peer->lock)); +if (unlikely (!bind)) + goto unlock2; -switch (bind->remote.in4.sin_family) { -case AF_INET : - salen =sizeof (*sa); -break ; -case AF_INET6 : - salen =sizeof (*sa6); -break ; - } +/* peer may have been concurrently removed between the caller's +* initial lookup and our acquisition of ovpn->lock; skip the +* rehash so we don't re-insert a removed peer +*/ +if (unlikely (hlist_unhashed (&peer->hash_entry_id))) + goto unlock2; -/* remove old hashing */ -hlist_nulls_del_init_rcu (&peer->hash_entry_transp_addr); -/* re-add with new transport address */ - nhead =ovpn_get_hash_head (peer->ovpn->peers->by_transp_addr, - &bind->remote, salen); -hlist_nulls_add_head_rcu (&peer->hash_entry_transp_addr, nhead); -spin_unlock_bh (&peer->lock); -spin_unlock_bh (&peer->ovpn->lock); +/* This function may be invoked concurrently, therefore another +* float may have happened in parallel: perform rehashing +* using the peer->bind->remote directly as key +*/ + +switch (bind->remote.in4.sin_family) { +case AF_INET : + salen =sizeof (*sa); +break ; +case AF_INET6 : + salen =sizeof (*sa6); +break ; } + +/* remove old hashing */ +hlist_nulls_del_init_rcu (&peer->hash_entry_transp_addr); +/* re-add with new transport address */ + nhead =ovpn_get_hash_head (peer->ovpn->peers->by_transp_addr, + &bind->remote, salen); +hlist_nulls_add_head_rcu (&peer->hash_entry_transp_addr, nhead); +unlock2: +spin_unlock_bh (&peer->lock); +spin_unlock_bh (&peer->ovpn->lock);return ; unlock:spin_unlock_bh (&peer->lock);
@@ -906,6 +912,13 @@ void ovpn_peer_hash_vpn_ip(struct ovpn_peer *peer)if (peer->ovpn->mode !=OVPN_MODE_MP )return ; +/* peer may have been concurrently removed between the caller's +* initial lookup and our acquisition of ovpn->lock; skip the +* rehash so we don't re-insert a removed peer +*/ +if (hlist_unhashed (&peer->hash_entry_id)) +return ; +if (peer->vpn_addrs.ipv4.s_addr !=htonl (INADDR_ANY )) {/* remove potential old hashing */ hlist_nulls_del_init_rcu (&peer->hash_entry_addr4);
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 5/9 ovpn: zero-initialize sockaddr before learning a floated endpoint
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
ovpn_peer_endpoints_update() builds the new remote endpoint in an on-stack struct sockaddr_storage that is left uninitialized. For IPv4 only sin_family/sin_addr/sin_port are written, leaving the 8-byte sin_zero padding as stack garbage (for IPv6, sin6_flowinfo is left uninitialized likewise).
ovpn_peer_reset_sockaddr() -> ovpn_bind_from_sockaddr() then memcpy()s sizeof(struct sockaddr_in)/sizeof(struct sockaddr_in6) bytes - padding included - into bind->remote. That buffer is later hashed with jhash() over the same length to place the peer in the by_transp_addr table, so the garbage padding lands the floated peer in an essentially random bucket. Lockless lookups in ovpn_peer_get_by_transp_addr() build their key from a zero-initialized sockaddr_storage, compute a different bucket and fail to find the peer.
This is also a plain use of uninitialized stack memory in jhash().
Zero-initialize the sockaddr_storage, matching what the lookup and netlink paths already do.
--- drivers/net/ovpn/peer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/ovpn/peer.c +1 -1
@@ -221,7 +221,7 @@ static void __ovpn_peer_hash_transp_addr(struct ovpn_peer *peer,*/ void ovpn_peer_endpoints_update (struct ovpn_peer *peer,struct sk_buff *skb) { -struct sockaddr_storage ss; +struct sockaddr_storage ss = {};struct sockaddr_in6 *sa6;bool reset_cache = false;struct sockaddr_in *sa;
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 7/9 ovpn: disable IPv4 redirects on MP interfaces
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
ovpn_mp_alloc() tried to disable SEND_REDIRECTS on a multipeer interface, but it runs from ovpn_net_init() (->ndo_init), which register_netdevice() invokes before the NETDEV_REGISTER notifier chain. The IPv4 in_device is only created when that notifier reaches inetdev_event() -> inetdev_init(), so __in_dev_get_rtnl() always returned NULL at ndo_init time and the whole redirect-disabling block (both the per-device and the per-netns IPV4_DEVCONF_ALL write) was dead. MP interfaces therefore kept emitting ICMP redirects.
Disabling redirects only once is not enough either: the IPv4 in_device is destroyed and recreated when the interface is moved to a different network namespace (NETDEV_UNREGISTER/NETDEV_REGISTER), and the newly created in_device inherits the destination namespace defaults, silently re-enabling SEND_REDIRECTS.
Disable redirects from ovpn_net_open() (->ndo_open) instead: it runs every time the interface is brought up, including after the in_device has been recreated, so the setting is always re-applied. This mirrors what wireguard does in wg_open(). RTNL is held on the ndo_open() path, so __in_dev_get_rtnl() is safe.
--- drivers/net/ovpn/main.c | 50 ++++++++++++++++++++++++++++------------- 1 file changed, 35 insertions(+), 15 deletions(-)
drivers/net/ovpn/main.c +35 -15
@@ -35,25 +35,11 @@ static void ovpn_priv_free(struct net_device *net)static int ovpn_mp_alloc (struct ovpn_priv *ovpn) { -struct in_device *dev_v4;int i;if (ovpn->mode !=OVPN_MODE_MP )return 0 ; - dev_v4 =__in_dev_get_rtnl (ovpn->dev); -if (dev_v4) { -/* disable redirects as Linux gets confused by ovpn -* handling same-LAN routing. -* This happens because a multipeer interface is used as -* relay point between hosts in the same subnet, while -* in a classic LAN this would not be needed because the -* two hosts would be able to talk directly. -*/ -IN_DEV_CONF_SET (dev_v4,SEND_REDIRECTS , false); -IPV4_DEVCONF_ALL (dev_net (ovpn->dev),SEND_REDIRECTS ) = false; - } -/* the peer container is fairly large, therefore we allocate it only in * MP mode */
@@ -97,9 +83,38 @@ static void ovpn_net_uninit(struct net_device *dev)gro_cells_destroy (&ovpn->gro_cells); } +static int ovpn_net_open (struct net_device *dev) +{ +struct ovpn_priv *ovpn =netdev_priv (dev); +struct in_device *dev_v4; + +/* the IPv4 in_device (and thus its config) is recreated whenever the +* interface is moved to a new netns, so redirects must be disabled on +* every bring-up rather than once at creation time, otherwise the +* setting is silently lost after such a move +*/ +if (ovpn->mode ==OVPN_MODE_MP ) { + dev_v4 =__in_dev_get_rtnl (dev); +if (dev_v4) { +/* disable redirects as Linux gets confused by ovpn +* handling same-LAN routing. +* This happens because a multipeer interface is used as +* relay point between hosts in the same subnet, while +* in a classic LAN this would not be needed because the +* two hosts would be able to talk directly. +*/ +IN_DEV_CONF_SET (dev_v4,SEND_REDIRECTS , false); +IPV4_DEVCONF_ALL (dev_net (dev),SEND_REDIRECTS ) = false; + } + } + +return 0 ; +} +static const struct net_device_ops ovpn_netdev_ops = { .ndo_init = ovpn_net_init, .ndo_uninit = ovpn_net_uninit, + .ndo_open = ovpn_net_open, .ndo_start_xmit = ovpn_net_xmit, };
@@ -183,6 +198,7 @@ static int ovpn_newlink(struct net_device *dev,struct ovpn_priv *ovpn =netdev_priv (dev);struct nlattr **data = params->data;enum ovpn_mode mode =OVPN_MODE_P2P ; +int ret;if (data && data[IFLA_OVPN_MODE ]) { mode =nla_get_u8 (data[IFLA_OVPN_MODE ]);
@@ -207,7 +223,11 @@ static int ovpn_newlink(struct net_device *dev,else netif_carrier_off (dev); -return register_netdevice (dev); + ret =register_netdevice (dev); +if (ret <0 ) +return ret; + +return 0 ; }static int ovpn_fill_info (struct sk_buff *skb,const struct net_device *dev)
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 6/9 ovpn: hash floated peer by transport identity only
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
The by_transp_addr table is keyed on the peer's remote transport address, but the float rehash hashed bind->remote directly, while the two other sites that touch the table build a clean key first:ovpn_peer_add_mp() and the lookup in ovpn_peer_get_by_transp_addr() both hash a sockaddr holding only family/address/port.
For a link-local IPv6 peer, bind->remote carries sin6_scope_id (set from ipv6_iface_scope_id() when the endpoint is learned), and that field is folded into the jhash() over sizeof(struct sockaddr_in6). The lookup never sets sin6_scope_id, so after such a peer floats it is rehashed into a scope_id-dependent bucket that lookups (scope_id 0) never visit, making the peer unreachable through the by_transp_addr fallback. ovpn_peer_transp_match() only compares address and port, so the hash was keying on a field the match ignores.
sin6_scope_id must stay in bind->remote because the TX path uses it as flowi6_oif, so it cannot just be cleared there. Instead build the hash key from family/address/port only, exactly like ovpn_peer_add_mp() and the lookup, so all three sites agree on the bucket.
--- drivers/net/ovpn/peer.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-)
drivers/net/ovpn/peer.c +21 -4
@@ -913,7 +913,10 @@ bool ovpn_peer_check_by_src(struct ovpn_priv *ovpn, struct sk_buff *skb,static void __ovpn_peer_hash_transp_addr (struct ovpn_peer *peer,const struct ovpn_bind *bind) { +struct sockaddr_storage sa = {};struct hlist_nulls_head *nhead; +struct sockaddr_in6 *sa6; +struct sockaddr_in *sa4;size_t salen;lockdep_assert_held (&peer->ovpn->lock);
@@ -929,12 +932,26 @@ static void __ovpn_peer_hash_transp_addr(struct ovpn_peer *peer,if (unlikely (hlist_unhashed (&peer->hash_entry_id)))return ; +/* Build the hash key from the transport identity only +* (family/address/port), matching ovpn_peer_add_mp() and the lookup +* in ovpn_peer_get_by_transp_addr(). Hashing bind->remote directly +* would fold in sin6_scope_id (set on the float path but never by the +* lookup), scattering the peer into a bucket lookups cannot reach. +*/ switch (bind->remote.in4.sin_family) {case AF_INET : - salen =sizeof (struct sockaddr_in ); + sa4 = (struct sockaddr_in *)&sa; + sa4->sin_family =AF_INET ; + sa4->sin_addr.s_addr = bind->remote.in4.sin_addr.s_addr; + sa4->sin_port = bind->remote.in4.sin_port; + salen =sizeof (*sa4);break ;case AF_INET6 : - salen =sizeof (struct sockaddr_in6 ); + sa6 = (struct sockaddr_in6 *)&sa; + sa6->sin6_family =AF_INET6 ; + sa6->sin6_addr = bind->remote.in6.sin6_addr; + sa6->sin6_port = bind->remote.in6.sin6_port; + salen =sizeof (*sa6);break ;default :return ;
@@ -943,8 +960,8 @@ static void __ovpn_peer_hash_transp_addr(struct ovpn_peer *peer,/* remove old hashing (no-op if entry is not currently linked) */ hlist_nulls_del_init_rcu (&peer->hash_entry_transp_addr);/* re-add with current transport address */ - nhead =ovpn_get_hash_head (peer->ovpn->peers->by_transp_addr, - &bind->remote, salen); + nhead =ovpn_get_hash_head (peer->ovpn->peers->by_transp_addr, &sa, + salen);hlist_nulls_add_head_rcu (&peer->hash_entry_transp_addr, nhead); }
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 8/9 ovpn: ensure TCP vars are initialized first
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
Netlink calls may access TCP global vars (i.e. when attaching a TCP socket), therefore we need to make sure the latters are initialized beforehand.
For this reason move the global TCP initialization at the top of the module init function.
--- drivers/net/ovpn/main.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
drivers/net/ovpn/main.c +7 -3
@@ -253,8 +253,14 @@ static struct rtnl_link_ops ovpn_link_ops = {static int __init ovpn_init (void ) { -int err =rtnl_link_register (&ovpn_link_ops); +int err; +/* init TCP first so that any subsequent netlink operation +* is ensured to access initialized TCP global vars +*/ +ovpn_tcp_init (); + + err =rtnl_link_register (&ovpn_link_ops);if (err) {pr_err ("ovpn: can't register rtnl link ops: %d\n" , err);return err;
@@ -266,8 +272,6 @@ static int __init ovpn_init(void) goto unreg_rtnl; } -ovpn_tcp_init (); -return 0 ; unreg_rtnl:
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
PATCH v3 9/9 ovpn: invalidate the UDP TX dst_cache when the flow key changes
In reply to Antonio QuartulliFrom: Antonio Quartulli <[email protected]>
ovpn_udp{4,6}_output() resolve a route from a flow key sampled from the peer binding and the transport socket, then cache the result in the per-peer dst_cache. Several of those sources may change concurrently with TX, and the dst_cache epoch (reset_ts vs the per-CPU refresh_ts stamped at get-miss time) only neutralizes the common ordering. Three issues remain:
- ovpn_peer_endpoints_update() may either update bind->local in place or replace the whole bind via RCU (float -> new remote, hence new daddr/dport/oif). It already dst_cache_reset()s, but the TX path can still cache a dst it resolved with the pre-update values if its dst_cache_get-miss lands a strictly later jiffy than the reset.
- inet_sk(sk)->inet_sport can be reset to 0 by __udp_disconnect() (connect() with AF_UNSPEC) on a socket without SOCK_BINDPORT_LOCK, and sk->sk_mark can change any time via setsockopt(SO_MARK). Neither triggers an ovpn cache reset, so a previously-cached entry resolved with the old value persists until dst obsolescence. Both fields are also read locklessly into the flow key (data race).
- A sport of 0 means the transport socket has been disconnected and unhashed; sending a UDP packet from source port 0 is nonsense.
In the common dispatcher ovpn_udp_output() (so every TX, including cache hits, runs the check):
- Sample inet_sport with READ_ONCE(). If it is 0, emit a one-time netdev_warn_once() and return -EIO so ovpn_udp_send_skb() drops the skb.
- Sample sk_mark with READ_ONCE().
- Compare both against the values stored when the dst_cache was last (re-)populated (new per-peer fields dst_cache_sport/dst_cache_mark, zero-initialised by kzalloc_obj() in ovpn_peer_new()). On mismatch dst_cache_reset() the cache and WRITE_ONCE() the new values, so the subsequent dst_cache_get() misses and the lookup re-resolves with the current sport/mark.
- Pass sport/mark down to ovpn_udp{4,6}_output(); they use those in the flowi initializer and skip the per-function sampling.
The post-lookup re-check in the v4/v6 paths is retained, but only for the bind/local race the original commit addressed (rcu_access_pointer on peer->bind and READ_ONCE/ovpn_peer_local_ipv6 on bind->local); the sport/mark comparison is dropped from there because the entry check now catches it. sk_protocol is immutable post-creation and is intentionally read plain.
The in-flight packet is still transmitted with the resolved parameters; only the cache is guarded. No fast-path lock is added.
--- drivers/net/ovpn/peer.h | 8 +++++ drivers/net/ovpn/udp.c | 70 +++++++++++++++++++++++++++++++++++------ 2 files changed, 68 insertions(+), 10 deletions(-)
drivers/net/ovpn/peer.h +8 -0
@@ -46,6 +46,12 @@* @tcp.sk_cb.ops: pointer to the original prot_ops object (TCP only) * @crypto: the crypto configuration (ciphers, keys, etc..) * @dst_cache: cache for dst_entry used to send to peer +* @dst_cache_sport: inet_sport observed when the dst_cache was last +* (re-)populated; compared on every TX to detect changes +* (e.g. connect(AF_UNSPEC)) and invalidate the cache +* @dst_cache_mark: sk_mark observed when the dst_cache was last +* (re-)populated; compared on every TX to detect changes +* via setsockopt(SO_MARK) and invalidate the cache * @bind: remote peer binding * @keepalive_interval: seconds after which a new keepalive should be sent * @keepalive_xmit_exp: future timestamp when next keepalive should be sent
@@ -102,6 +108,8 @@ struct ovpn_peer { } tcp;struct ovpn_crypto_state crypto;struct dst_cache dst_cache; +__be16 dst_cache_sport; +u32 dst_cache_mark;struct ovpn_bind __rcu *bind;unsigned long keepalive_interval;unsigned long keepalive_xmit_exp;
drivers/net/ovpn/udp.c +60 -10
131 lines not on this page · raw message
Signature · 8 lines
2.54.0 _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel
This series is being dropped to address a few subtle issues identified by Sashiko.
Regards,
Signature · 8 lines
Antonio Quartulli _______________________________________________ Openvpn-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openvpn-devel