tproxy fixes for current upstream code
Subsystems (4)
cover tproxy fixes for current upstream code
The following series fix a handful of issues which have been found in the current upstream IPv4 tproxy code:
* an issue with how port redirection interacts with TCP TIME_WAIT sockets
* UDP socket lookup fixes so that now it prefers connected sockets, etc.
* fix for a bind hash issue which could trigger crashes when port redirection was used.
---
Balazs Scheidler (2):
tproxy: kick out TIME_WAIT sockets in case a new connection comes in with the same tuple
tproxy: add lookup type checks for UDP in nf_tproxy_get_sock_v4()
KOVACS Krisztian (1):
tproxy: fix hash locking issue when using port redirection in __inet_inherit_port()
include/net/inet_hashtables.h | 2 - include/net/netfilter/nf_tproxy_core.h | 120 +++++++++++++++++++++++++++++++- net/dccp/ipv4.c | 10 ++- net/dccp/ipv6.c | 10 ++- net/ipv4/inet_hashtables.c | 28 +++++++ net/ipv4/tcp_ipv4.c | 10 ++- net/ipv6/tcp_ipv6.c | 12 ++- net/netfilter/nf_tproxy_core.c | 35 --------- net/netfilter/xt_TPROXY.c | 68 +++++++++++++++++- net/netfilter/xt_socket.c | 2 - 10 files changed, 238 insertions(+), 59 deletions(-)
Signature · 1 line
KOVACS Krisztian
PATCH 1/3 tproxy: kick out TIME_WAIT sockets in case a new connection comes in with the same tuple
From: Balazs Scheidler <[email protected]>
Without tproxy redirections an incoming SYN kicks out conflicting TIME_WAIT sockets, in order to handle clients that reuse ports within the TIME_WAIT period.
The same mechanism didn't work in case TProxy is involved in finding the proper socket, as the time_wait processing code looked up the listening socket assuming that the listener addr/port matches those of the established connection.
This is not the case with TProxy as the listener addr/port is possibly changed with the tproxy rule.
--- include/net/netfilter/nf_tproxy_core.h | 6 ++- net/netfilter/nf_tproxy_core.c | 29 ++++++++++---- net/netfilter/xt_TPROXY.c | 68 ++++++++++++++++++++++++++++++-- net/netfilter/xt_socket.c | 2 - 4 files changed, 90 insertions(+), 15 deletions(-)
include/net/netfilter/nf_tproxy_core.h +5 -1
@@ -8,12 +8,16 @@#include <net/inet_sock.h> #include <net/tcp.h> +#define NFT_LOOKUP_ANY 0 +#define NFT_LOOKUP_LISTENER 1 +#define NFT_LOOKUP_ESTABLISHED 2 +/* look up and get a reference to a matching socket */ extern struct sock *nf_tproxy_get_sock_v4 (struct net *net,const u8 protocol,const __be32 saddr,const __be32 daddr,const __be16 sport,const __be16 dport, -const struct net_device *in,bool listening); +const struct net_device *in,int lookup_type);static inline void nf_tproxy_put_sock (struct sock *sk)
net/netfilter/nf_tproxy_core.c +21 -8
@@ -22,21 +22,34 @@ struct sock * nf_tproxy_get_sock_v4(struct net *net, const u8 protocol, const __be32 saddr, const __be32 daddr, const __be16 sport, const __be16 dport, - const struct net_device *in, bool listening_only) + const struct net_device *in, int lookup_type) { struct sock *sk;/* look up socket */ switch (protocol) { case IPPROTO_TCP: - if (listening_only) - sk = __inet_lookup_listener(net, &tcp_hashinfo, - daddr, ntohs(dport), - in->ifindex); - else + switch (lookup_type) { + case NFT_LOOKUP_ANY: sk = __inet_lookup(net, &tcp_hashinfo, saddr, sport, daddr, dport, in->ifindex); + break; + case NFT_LOOKUP_LISTENER: + sk = inet_lookup_listener(net, &tcp_hashinfo, + daddr, dport, + in->ifindex); + break; + case NFT_LOOKUP_ESTABLISHED: + sk = inet_lookup_established(net, &tcp_hashinfo, + saddr, sport, daddr, dport, + in->ifindex); + break; + default: + WARN_ON(1); + sk = NULL; + break; + } break; case IPPROTO_UDP: sk = udp4_lib_lookup(net, saddr, sport, daddr, dport,
@@ -47,8 +60,8 @@ nf_tproxy_get_sock_v4(struct net *net, const u8 protocol, sk =NULL ; } -pr_debug ("tproxy socket lookup: proto %u %08x:%u -> %08x:%u, listener only: %d, sock %p\n" , - protocol,ntohl (saddr),ntohs (sport),ntohl (daddr),ntohs (dport), listening_only, sk); +pr_debug ("tproxy socket lookup: proto %u %08x:%u -> %08x:%u, lookup type: %d, sock %p\n" , + protocol,ntohl (saddr),ntohs (sport),ntohl (daddr),ntohs (dport), lookup_type, sk);return sk; }
net/netfilter/xt_TPROXY.c +63 -5
80 lines not on this page · raw message
net/netfilter/xt_socket.c +1 -1
@@ -142,7 +142,7 @@ socket_match(const struct sk_buff *skb, struct xt_action_param *par,#endif sk =nf_tproxy_get_sock_v4 (dev_net (skb->dev), protocol, - saddr, daddr, sport, dport, par->in, false); + saddr, daddr, sport, dport, par->in,NFT_LOOKUP_ANY );if (sk !=NULL ) {bool wildcard;bool transparent = true;
Patrick McHardy
AppliedRe: [PATCH 1/3] tproxy: kick out TIME_WAIT sockets in case a new connection comes in with the same tuple
Am 20.10.2010 13:21, schrieb KOVACS Krisztian:
Quoted 11 lines
Without tproxy redirections an incoming SYN kicks out conflicting
TIME_WAITsockets, in order to handle clients that reuse ports within theTIME_WAITperiod.The same mechanism didn't work in case TProxy is involved in finding the proper socket, as the
time_waitprocessing code looked up the listening socket assuming that the listener addr/port matches those of the established connection.This is not the case with TProxy as the listener addr/port is possibly changed with the tproxy rule.
Applied, thanks.
PATCH 2/3 tproxy: add lookup type checks for UDP in nf_tproxy_get_sock_v4()
In reply to KOVACS KrisztianFrom: Balazs Scheidler <[email protected]>
Also, inline this function as the lookup_type is always a literal and inlining removes branches performed at runtime.
--- include/net/netfilter/nf_tproxy_core.h | 116 +++++++++++++++++++++++++++++++- net/netfilter/nf_tproxy_core.c | 48 ------------- 2 files changed, 114 insertions(+), 50 deletions(-)
include/net/netfilter/nf_tproxy_core.h +114 -2
@@ -13,11 +13,123 @@#define NFT_LOOKUP_ESTABLISHED 2/* look up and get a reference to a matching socket */ -extern struct sock * + + +/* This function is used by the 'TPROXY' target and the 'socket' +* match. The following lookups are supported: +* +* Explicit TProxy target rule +* =========================== +* +* This is used when the user wants to intercept a connection matching +* an explicit iptables rule. In this case the sockets are assumed +* matching in preference order: +* +* - match: if there's a fully established connection matching the +* _packet_ tuple, it is returned, assuming the redirection +* already took place and we process a packet belonging to an +* established connection +* +* - match: if there's a listening socket matching the redirection +* (e.g. on-port & on-ip of the connection), it is returned, +* regardless if it was bound to 0.0.0.0 or an explicit +* address. The reasoning is that if there's an explicit rule, it +* does not really matter if the listener is bound to an interface +* or to 0. The user already stated that he wants redirection +* (since he added the rule). +* +* "socket" match based redirection (no specific rule) +* =================================================== +* +* There are connections with dynamic endpoints (e.g. FTP data +* connection) that the user is unable to add explicit rules +* for. These are taken care of by a generic "socket" rule. It is +* assumed that the proxy application is trusted to open such +* connections without explicit iptables rule (except of course the +* generic 'socket' rule). In this case the following sockets are +* matched in preference order: +* +* - match: if there's a fully established connection matching the +* _packet_ tuple +* +* - match: if there's a non-zero bound listener (possibly with a +* non-local address) We don't accept zero-bound listeners, since +* then local services could intercept traffic going through the +* box. +* +* Please note that there's an overlap between what a TPROXY target +* and a socket match will match. Normally if you have both rules the +* "socket" match will be the first one, effectively all packets +* belonging to established connections going through that one. +*/ +static inline struct sock *nf_tproxy_get_sock_v4 (struct net *net,const u8 protocol,const __be32 saddr,const __be32 daddr,const __be16 sport,const __be16 dport, -const struct net_device *in,int lookup_type); +const struct net_device *in,int lookup_type) +{ +struct sock *sk; + +/* look up socket */ +switch (protocol) { +case IPPROTO_TCP : +switch (lookup_type) { +case NFT_LOOKUP_ANY : + sk =__inet_lookup (net, &tcp_hashinfo, + saddr, sport, daddr, dport, + in->ifindex); +break ; +case NFT_LOOKUP_LISTENER : + sk =inet_lookup_listener (net, &tcp_hashinfo, + daddr, dport, + in->ifindex); + +/* NOTE: we return listeners even if bound to +* 0.0.0.0, those are filtered out in +* xt_socket, since xt_TPROXY needs 0 bound +* listeners too */ + +break ; +case NFT_LOOKUP_ESTABLISHED : + sk =inet_lookup_established (net, &tcp_hashinfo, + saddr, sport, daddr, dport, + in->ifindex); +break ; +default : +WARN_ON (1 ); + sk =NULL ; +break ; + } +break ; +case IPPROTO_UDP : + sk =udp4_lib_lookup (net, saddr, sport, daddr, dport, + in->ifindex); +if (sk && lookup_type !=NFT_LOOKUP_ANY ) { +int connected = (sk->sk_state ==TCP_ESTABLISHED ); +int wildcard = (inet_sk (sk)->inet_rcv_saddr ==0 ); + +/* NOTE: we return listeners even if bound to +* 0.0.0.0, those are filtered out in +* xt_socket, since xt_TPROXY needs 0 bound +* listeners too */ +if ((lookup_type ==NFT_LOOKUP_ESTABLISHED && (!connected || wildcard)) || + (lookup_type ==NFT_LOOKUP_LISTENER && connected)) { +sock_put (sk); + sk =NULL ; + } + } +break ; +default : +WARN_ON (1 ); + sk =NULL ; + } + +pr_debug ("tproxy socket lookup: proto %u %08x:%u -> %08x:%u, lookup type: %d, sock %p\n" , + protocol,ntohl (saddr),ntohs (sport),ntohl (daddr),ntohs (dport), lookup_type, sk); + +return sk; +} +static inline void nf_tproxy_put_sock (struct sock *sk)
net/netfilter/nf_tproxy_core.c +0 -48
54 lines not on this page · raw message
Patrick McHardy
AppliedRe: [PATCH 2/3] tproxy: add lookup type checks for UDP in nf_tproxy_get_sock_v4()
Am 20.10.2010 13:21, schrieb KOVACS Krisztian:
Quoted 2 lines
Also, inline this function as the
lookup_typeis always a literal and inlining removes branches performed at runtime.
Applied, thanks.
PATCH 3/3 tproxy: fix hash locking issue when using port redirection in __inet_inherit_port()
In reply to KOVACS KrisztianWhen __inet_inherit_port() is called on a tproxy connection the wrong locks are held for the inet_bind_bucket it is added to. __inet_inherit_port() made an implicit assumption that the listener's port number (and thus its bind bucket). Unfortunately, if you're using the TPROXY target to redirect skbs to a transparent proxy that assumption is not true anymore and things break.
This patch adds code to __inet_inherit_port() so that it can handle this case by looking up or creating a new bind bucket for the child socket and updates callers of __inet_inherit_port() to gracefully handle __inet_inherit_port() failing.
Reported by and original patch from Stephen Buck <[email protected]>. See http://marc.info/?t=128169268200001&r=1&w=2 for the original discussion.
--- include/net/inet_hashtables.h | 2 +- net/dccp/ipv4.c | 10 +++++++--- net/dccp/ipv6.c | 10 +++++++--- net/ipv4/inet_hashtables.c | 28 ++++++++++++++++++++++++++-- net/ipv4/tcp_ipv4.c | 10 +++++++--- net/ipv6/tcp_ipv6.c | 12 ++++++++---- 6 files changed, 56 insertions(+), 16 deletions(-)
include/net/inet_hashtables.h +1 -1
@@ -245,7 +245,7 @@ static inline int inet_sk_listen_hashfn(const struct sock *sk) }/* Caller must disable local BH processing. */ -extern void __inet_inherit_port (struct sock *sk,struct sock *child); +extern int __inet_inherit_port (struct sock *sk,struct sock *child);extern void inet_put_port (struct sock *sk);
net/dccp/ipv4.c +7 -3
@@ -392,7 +392,7 @@ struct sock *dccp_v4_request_recv_sock(struct sock *sk, struct sk_buff *skb, newsk =dccp_create_openreq_child (sk, req, skb);if (newsk ==NULL ) - goto exit; + goto exit_nonewsk;sk_setup_caps (newsk, dst);
@@ -409,16 +409,20 @@ struct sock *dccp_v4_request_recv_sock(struct sock *sk, struct sk_buff *skb,dccp_sync_mss (newsk,dst_mtu (dst)); +if (__inet_inherit_port (sk, newsk) <0 ) { +sock_put (newsk); + goto exit; + }__inet_hash_nolisten (newsk,NULL ); -__inet_inherit_port (sk, newsk);return newsk; exit_overflow:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENOVERFLOWS ); +exit_nonewsk: +dst_release (dst); exit:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENDROPS ); -dst_release (dst);return NULL ; }
net/dccp/ipv6.c +7 -3
@@ -564,7 +564,7 @@ static struct sock *dccp_v6_request_recv_sock(struct sock *sk, newsk =dccp_create_openreq_child (sk, req, skb);if (newsk ==NULL ) - goto out; + goto out_nonewsk;/* * No need to charge this sock to the relevant IPv6 refcnt debug socks
@@ -632,18 +632,22 @@ static struct sock *dccp_v6_request_recv_sock(struct sock *sk, newinet->inet_daddr = newinet->inet_saddr =LOOPBACK4_IPV6 ; newinet->inet_rcv_saddr =LOOPBACK4_IPV6 ; +if (__inet_inherit_port (sk, newsk) <0 ) { +sock_put (newsk); + goto out; + }__inet6_hash (newsk,NULL ); -__inet_inherit_port (sk, newsk);return newsk; out_overflow:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENOVERFLOWS ); +out_nonewsk: +dst_release (dst); out:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENDROPS );if (opt !=NULL && opt != np->opt)sock_kfree_s (sk, opt, opt->tot_len); -dst_release (dst);return NULL ; }
net/ipv4/inet_hashtables.c +26 -2
@@ -101,19 +101,43 @@ void inet_put_port(struct sock *sk) }EXPORT_SYMBOL (inet_put_port); -void __inet_inherit_port (struct sock *sk,struct sock *child) +int __inet_inherit_port (struct sock *sk,struct sock *child) {struct inet_hashinfo *table = sk->sk_prot->h.hashinfo; -const int bhash =inet_bhashfn (sock_net (sk),inet_sk (child)->inet_num, +unsigned short port =inet_sk (child)->inet_num; +const int bhash =inet_bhashfn (sock_net (sk), port, table->bhash_size);struct inet_bind_hashbucket *head = &table->bhash[bhash];struct inet_bind_bucket *tb;spin_lock (&head->lock); tb =inet_csk (sk)->icsk_bind_hash; +if (tb->port != port) { +/* NOTE: using tproxy and redirecting skbs to a proxy +* on a different listener port breaks the assumption +* that the listener socket's icsk_bind_hash is the same +* as that of the child socket. We have to look up or +* create a new bind bucket for the child here. */ +struct hlist_node *node; +inet_bind_bucket_for_each (tb, node, &head->chain) { +if (net_eq (ib_net (tb),sock_net (sk)) && + tb->port == port) +break ; + } +if (!node) { + tb =inet_bind_bucket_create (table->bind_bucket_cachep, +sock_net (sk), head, port); +if (!tb) { +spin_unlock (&head->lock); +return -ENOMEM ; + } + } + }sk_add_bind_node (child, &tb->owners);inet_csk (child)->icsk_bind_hash = tb;spin_unlock (&head->lock); + +return 0 ; }EXPORT_SYMBOL_GPL (__inet_inherit_port);
net/ipv4/tcp_ipv4.c +7 -3
@@ -1422,7 +1422,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, newsk =tcp_create_openreq_child (sk, req, skb);if (!newsk) - goto exit; + goto exit_nonewsk; newsk->sk_gso_type =SKB_GSO_TCPV4 ;sk_setup_caps (newsk, dst);
@@ -1469,16 +1469,20 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, }#endif +if (__inet_inherit_port (sk, newsk) <0 ) { +sock_put (newsk); + goto exit; + }__inet_hash_nolisten (newsk,NULL ); -__inet_inherit_port (sk, newsk);return newsk; exit_overflow:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENOVERFLOWS ); +exit_nonewsk: +dst_release (dst); exit:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENDROPS ); -dst_release (dst);return NULL ; }EXPORT_SYMBOL (tcp_v4_syn_recv_sock);
net/ipv6/tcp_ipv6.c +8 -4
@@ -1409,7 +1409,7 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, newsk =tcp_create_openreq_child (sk, req, skb);if (newsk ==NULL ) - goto out; + goto out_nonewsk;/* * No need to charge this sock to the relevant IPv6 refcnt debug socks
@@ -1497,18 +1497,22 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, }#endif +if (__inet_inherit_port (sk, newsk) <0 ) { +sock_put (newsk); + goto out; + }__inet6_hash (newsk,NULL ); -__inet_inherit_port (sk, newsk);return newsk; out_overflow:NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENOVERFLOWS ); -out: -NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENDROPS ); +out_nonewsk:if (opt && opt != np->opt)sock_kfree_s (sk, opt, opt->tot_len);dst_release (dst); +out: +NET_INC_STATS_BH (sock_net (sk),LINUX_MIB_LISTENDROPS );return NULL ; }
Patrick McHardy
AppliedRe: [PATCH 3/3] tproxy: fix hash locking issue when using port redirection in __inet_inherit_port()
Am 20.10.2010 13:21, schrieb KOVACS Krisztian:
Quoted 6 lines
When
__inet_inherit_port()is called on a tproxy connection the wrong locks are held for theinet_bind_bucketit is added to.__inet_inherit_port()made an implicit assumption that the listener's port number (and thus its bind bucket). Unfortunately, if you're using the TPROXY target to redirect skbs to a transparent proxy that assumption is not true anymore and things break.
Quoted 7 lines
This patch adds code to
__inet_inherit_port()so that it can handle this case by looking up or creating a new bind bucket for the child socket and updates callers of__inet_inherit_port()to gracefully handle__inet_inherit_port()failing.Reported by and original patch from Stephen Buck <[email protected]>. See http://marc.info/?t=128169268200001&r=1&w=2 for the original discussion.
Applied, thanks.