Netfilter fixes for net
Subsystems (4)
Pablo Neira Ayuso
maintainercover Netfilter fixes for net
Hi,
This patchset contains Netfilter fixes for net:
1) Extend selftest to cover flowtable with ipsec, from Florian Westphal.
2) Fix interaction of ipsec with flowtable, also from Florian.
3) User-after-free with bound set to rule that fails to load.
4) Adjust state and timeout for flows that expire.
5) Timeout update race with flows in teardown state.
6) Ensure conntrack id hash calculation use invariants as input, from Dirk Morris.
7) Do not push flows into flowtable for TCP fin/rst packets.
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
Thanks.
----------------------------------------------------------------
The following changes since commit 5e5412c365a32e452daa762eac36121cb8a370bb:
net/socket: fix GCC8+ Wpacked-not-aligned warnings (2019-08-03 11:02:46 -0700)
are available in the git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git HEAD
for you to fetch changes up to dfe42be15fde16232340b8b2a57c359f51cc10d9:
netfilter: nft_flow_offload: skip tcp rst and fin packets (2019-08-14 11:09:07 +0200)
----------------------------------------------------------------
Dirk Morris (1):
netfilter: conntrack: Use consistent ct id hash calculation
Florian Westphal (2):
selftests: netfilter: extend flowtable test script for ipsec
netfilter: nf_flow_table: fix offload for flows that are subject to xfrm
Pablo Neira Ayuso (4):
netfilter: nf_tables: use-after-free in failing rule with bound set
netfilter: nf_flow_table: conntrack picks up expired flows
netfilter: nf_flow_table: teardown flow timeout race
netfilter: nft_flow_offload: skip tcp rst and fin packets
include/net/netfilter/nf_tables.h | 9 +++- net/netfilter/nf_conntrack_core.c | 16 ++++---- net/netfilter/nf_flow_table_core.c | 43 +++++++++++++------ net/netfilter/nf_flow_table_ip.c | 43 +++++++++++++++++++ net/netfilter/nf_tables_api.c | 15 ++++--- net/netfilter/nft_flow_offload.c | 9 ++-- tools/testing/selftests/netfilter/nft_flowtable.sh | 48 ++++++++++++++++++++++ 7 files changed, 153 insertions(+), 30 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/7 selftests: netfilter: extend flowtable test script for ipsec
From: Florian Westphal <[email protected]>
'flow offload' expression should not offload flows that will be subject to ipsec, but it does.
This results in a connectivity blackhole for the affected flows -- first packets will go through (offload happens after established state is reached), but all remaining ones bypass ipsec encryption and are thus discarded by the peer.
This can be worked around by adding "rt ipsec exists accept" before the 'flow offload' rule matches.
This test case will fail, support for such flows is added in next patch.
--- tools/testing/selftests/netfilter/nft_flowtable.sh | 48 ++++++++++++++++++++++ 1 file changed, 48 insertions(+)
tools/testing/selftests/netfilter/nft_flowtable.sh +48 -0
@@ -321,4 +321,52 @@ else ip netns exec nsr1 nft list ruleset fi +KEY_SHA="0x"$(ps -xaf | sha1sum | cut -d " " -f 1) +KEY_AES="0x"$(ps -xaf | md5sum | cut -d " " -f 1) +SPI1=$RANDOM +SPI2=$RANDOM + +if [ $SPI1 -eq $SPI2 ]; then + SPI2=$((SPI2+1)) +fi + +do_esp() { + local ns=$1 + local me=$2 + local remote=$3 + local lnet=$4 + local rnet=$5 + local spi_out=$6 + local spi_in=$7 + + ip -net $ns xfrm state add src $remote dst $me proto esp spi $spi_in enc aes $KEY_AES auth sha1 $KEY_SHA mode tunnel sel src $rnet dst $lnet + ip -net $ns xfrm state add src $me dst $remote proto esp spi $spi_out enc aes $KEY_AES auth sha1 $KEY_SHA mode tunnel sel src $lnet dst $rnet + + # to encrypt packets as they go out (includes forwarded packets that need encapsulation) + ip -net $ns xfrm policy add src $lnet dst $rnet dir out tmpl src $me dst $remote proto esp mode tunnel priority 1 action allow + # to fwd decrypted packets after esp processing: + ip -net $ns xfrm policy add src $rnet dst $lnet dir fwd tmpl src $remote dst $me proto esp mode tunnel priority 1 action allow + +} + +do_esp nsr1 192.168.10.1 192.168.10.2 10.0.1.0/24 10.0.2.0/24 $SPI1 $SPI2 + +do_esp nsr2 192.168.10.2 192.168.10.1 10.0.2.0/24 10.0.1.0/24 $SPI2 $SPI1 + +ip netns exec nsr1 nft delete table ip nat + +# restore default routes +ip -net ns2 route del 192.168.10.1 via 10.0.2.1 +ip -net ns2 route add default via 10.0.2.1 +ip -net ns2 route add default via dead:2::1 + +test_tcp_forwarding ns1 ns2 +if [ $? -eq 0 ] ;then + echo "PASS: ipsec tunnel mode for ns1/ns2" +else + echo "FAIL: ipsec tunnel mode for ns1/ns2" + ip netns exec nsr1 nft list ruleset 1>&2 + ip netns exec nsr1 cat /proc/net/xfrm_stat 1>&2 +fi + exit $ret
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 2/7 netfilter: nf_flow_table: fix offload for flows that are subject to xfrm
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
This makes the previously added 'encap test' pass.
Because its possible that the xfrm dst entry becomes stale while such a flow is offloaded, we need to call dst_check() -- the notifier that handles this for non-tunneled traffic isn't sufficient, because SA or or policies might have changed.
If dst becomes stale the flow offload entry will be tagged for teardown and packets will be passed to 'classic' forwarding path.
Removing the entry right away is problematic, as this would introduce a race condition with the gc worker.
In case flow is long-lived, it could eventually be offloaded again once the gc worker removes the entry from the flow table.
--- net/netfilter/nf_flow_table_ip.c | 43 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
net/netfilter/nf_flow_table_ip.c +43 -0
@@ -214,6 +214,25 @@ static bool nf_flow_exceeds_mtu(const struct sk_buff *skb, unsigned int mtu)return true; } +static int nf_flow_offload_dst_check (struct dst_entry *dst) +{ +if (unlikely (dst_xfrm (dst))) +return dst_check (dst,0 ) ?0 :-1 ; + +return 0 ; +} + +static unsigned int nf_flow_xmit_xfrm (struct sk_buff *skb, +const struct nf_hook_state *state, +struct dst_entry *dst) +{ +skb_orphan (skb); +skb_dst_set_noref (skb, dst); + skb->tstamp =0 ; +dst_output (state->net, state->sk, skb); +return NF_STOLEN ; +} +unsigned int nf_flow_offload_ip_hook (void *priv,struct sk_buff *skb,const struct nf_hook_state *state)
@@ -254,6 +273,11 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,if (nf_flow_state_check (flow,ip_hdr (skb)->protocol, skb, thoff))return NF_ACCEPT ; +if (nf_flow_offload_dst_check (&rt->dst)) { +flow_offload_teardown (flow); +return NF_ACCEPT ; + } +if (nf_flow_nat_ip (flow, skb, thoff, dir) <0 )return NF_DROP ;
@@ -261,6 +285,13 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb, iph =ip_hdr (skb);ip_decrease_ttl (iph); +if (unlikely (dst_xfrm (&rt->dst))) { +memset (skb->cb,0 ,sizeof (struct inet_skb_parm )); +IPCB (skb)->iif = skb->dev->ifindex; +IPCB (skb)->flags =IPSKB_FORWARDED ; +return nf_flow_xmit_xfrm (skb, state, &rt->dst); + } + skb->dev = outdev; nexthop =rt_nexthop (rt, flow->tuplehash[!dir].tuple.src_v4.s_addr);skb_dst_set_noref (skb, &rt->dst);
@@ -467,6 +498,11 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb, sizeof(*ip6h)))return NF_ACCEPT ; +if (nf_flow_offload_dst_check (&rt->dst)) { +flow_offload_teardown (flow); +return NF_ACCEPT ; + } +if (skb_try_make_writable (skb,sizeof (*ip6h)))return NF_DROP ;
@@ -477,6 +513,13 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb, ip6h =ipv6_hdr (skb); ip6h->hop_limit--; +if (unlikely (dst_xfrm (&rt->dst))) { +memset (skb->cb,0 ,sizeof (struct inet6_skb_parm )); +IP6CB (skb)->iif = skb->dev->ifindex; +IP6CB (skb)->flags =IP6SKB_FORWARDED ; +return nf_flow_xmit_xfrm (skb, state, &rt->dst); + } + skb->dev = outdev; nexthop =rt6_nexthop (rt, &flow->tuplehash[!dir].tuple.src_v6);skb_dst_set_noref (skb, &rt->dst);
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 3/7 netfilter: nf_tables: use-after-free in failing rule with bound set
In reply to Pablo Neira AyusoIf a rule that has already a bound anonymous set fails to be added, the preparation phase releases the rule and the bound set. However, the transaction object from the abort path still has a reference to the set object that is stale, leading to a use-after-free when checking for the set->bound field. Add a new field to the transaction that specifies if the set is bound, so the abort path can skip releasing it since the rule command owns it and it takes care of releasing it. After this update, the set->bound field is removed.
[ 24.649883] Unable to handle kernel paging request at virtual address 0000000000040434 [ 24.657858] Mem abort info: [ 24.660686] ESR = 0x96000004 [ 24.663769] Exception class = DABT (current EL), IL = 32 bits [ 24.669725] SET = 0, FnV = 0 [ 24.672804] EA = 0, S1PTW = 0 [ 24.675975] Data abort info: [ 24.678880] ISV = 0, ISS = 0x00000004 [ 24.682743] CM = 0, WnR = 0 [ 24.685723] user pgtable: 4k pages, 48-bit VAs, pgdp=0000000428952000 [ 24.692207] [0000000000040434] pgd=0000000000000000 [ 24.697119] Internal error: Oops: 96000004 [#1] SMP [...] [ 24.889414] Call trace: [ 24.891870] __nf_tables_abort+0x3f0/0x7a0 [ 24.895984] nf_tables_abort+0x20/0x40 [ 24.899750] nfnetlink_rcv_batch+0x17c/0x588 [ 24.904037] nfnetlink_rcv+0x13c/0x190 [ 24.907803] netlink_unicast+0x18c/0x208 [ 24.911742] netlink_sendmsg+0x1b0/0x350 [ 24.915682] sock_sendmsg+0x4c/0x68 [ 24.919185] ___sys_sendmsg+0x288/0x2c8 [ 24.923037] __sys_sendmsg+0x7c/0xd0 [ 24.926628] __arm64_sys_sendmsg+0x2c/0x38 [ 24.930744] el0_svc_common.constprop.0+0x94/0x158 [ 24.935556] el0_svc_handler+0x34/0x90 [ 24.939322] el0_svc+0x8/0xc [ 24.942216] Code: 37280300 f9404023 91014262 aa1703e0 (f9401863) [ 24.948336] ---[ end trace cebbb9dcbed3b56f ]---
--- include/net/netfilter/nf_tables.h | 9 +++++++-- net/netfilter/nf_tables_api.c | 15 ++++++++++----- 2 files changed, 17 insertions(+), 7 deletions(-)
include/net/netfilter/nf_tables.h +7 -2
@@ -421,8 +421,7 @@ struct nft_set {unsigned char *udata;/* runtime data below here */ const struct nft_set_ops *ops____cacheline_aligned ; - u16 flags:13, - bound:1, + u16 flags:14, genmask:2;u8 klen;u8 dlen;
@@ -1348,12 +1347,15 @@ struct nft_trans_rule {struct nft_trans_set {struct nft_set *set;u32 set_id; +bool bound; };#define nft_trans_set (trans) \ (((struct nft_trans_set *)trans->data)->set)#define nft_trans_set_id (trans) \ (((struct nft_trans_set *)trans->data)->set_id) +#define nft_trans_set_bound (trans) \ + (((struct nft_trans_set *)trans->data)->bound)struct nft_trans_chain {bool update;
@@ -1384,12 +1386,15 @@ struct nft_trans_table {struct nft_trans_elem {struct nft_set *set;struct nft_set_elem elem; +bool bound; };#define nft_trans_elem_set (trans) \ (((struct nft_trans_elem *)trans->data)->set)#define nft_trans_elem (trans) \ (((struct nft_trans_elem *)trans->data)->elem) +#define nft_trans_elem_set_bound (trans) \ + (((struct nft_trans_elem *)trans->data)->bound)struct nft_trans_obj {struct nft_object *obj;
net/netfilter/nf_tables_api.c +10 -5
@@ -138,9 +138,14 @@ static void nft_set_trans_bind(const struct nft_ctx *ctx, struct nft_set *set)return ;list_for_each_entry_reverse (trans, &net->nft.commit_list, list) { -if (trans->msg_type ==NFT_MSG_NEWSET && -nft_trans_set (trans) == set) { - set->bound = true; +switch (trans->msg_type) { +case NFT_MSG_NEWSET : +if (nft_trans_set (trans) == set) +nft_trans_set_bound (trans) = true; +break ; +case NFT_MSG_NEWSETELEM : +if (nft_trans_elem_set (trans) == set) +nft_trans_elem_set_bound (trans) = true;break ; } }
@@ -6906,7 +6911,7 @@ static int __nf_tables_abort(struct net *net)break ;case NFT_MSG_NEWSET : trans->ctx.table->use--; -if (nft_trans_set (trans)->bound) { +if (nft_trans_set_bound (trans)) {nft_trans_destroy (trans);break ; }
@@ -6918,7 +6923,7 @@ static int __nf_tables_abort(struct net *net)nft_trans_destroy (trans);break ;case NFT_MSG_NEWSETELEM : -if (nft_trans_elem_set (trans)->bound) { +if (nft_trans_elem_set_bound (trans)) {nft_trans_destroy (trans);break ; }
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 4/7 netfilter: nf_flow_table: conntrack picks up expired flows
In reply to Pablo Neira AyusoUpdate conntrack entry to pick up expired flows, otherwise the conntrack entry gets stuck with the internal offload timeout (one day). The TCP state also needs to be adjusted to ESTABLISHED state and tracking is set to liberal mode in order to give conntrack a chance to pick up the expired flow.
--- net/netfilter/nf_flow_table_core.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-)
net/netfilter/nf_flow_table_core.c +10 -7
@@ -111,7 +111,7 @@ static void flow_offload_fixup_tcp(struct ip_ct_tcp *tcp)#define NF_FLOWTABLE_TCP_PICKUP_TIMEOUT (120 * HZ)#define NF_FLOWTABLE_UDP_PICKUP_TIMEOUT (30 * HZ) -static void flow_offload_fixup_ct_state (struct nf_conn *ct) +static void flow_offload_fixup_ct (struct nf_conn *ct) {const struct nf_conntrack_l4proto *l4proto;unsigned int timeout;
@@ -208,6 +208,11 @@ int flow_offload_add(struct nf_flowtable *flow_table, struct flow_offload *flow) }EXPORT_SYMBOL_GPL (flow_offload_add); +static inline bool nf_flow_has_expired (const struct flow_offload *flow) +{ +return (__s32)(flow->timeout - (u32 )jiffies) <=0 ; +} +static void flow_offload_del (struct nf_flowtable *flow_table,struct flow_offload *flow) {
@@ -223,6 +228,9 @@ static void flow_offload_del(struct nf_flowtable *flow_table, e = container_of(flow, struct flow_offload_entry, flow);clear_bit (IPS_OFFLOAD_BIT , &e->ct->status); +if (nf_flow_has_expired (flow)) +flow_offload_fixup_ct (e->ct); +flow_offload_free (flow); }
@@ -233,7 +241,7 @@ void flow_offload_teardown(struct flow_offload *flow) flow->flags |=FLOW_OFFLOAD_TEARDOWN ; e = container_of(flow, struct flow_offload_entry, flow); -flow_offload_fixup_ct_state (e->ct); +flow_offload_fixup_ct (e->ct); }EXPORT_SYMBOL_GPL (flow_offload_teardown);
@@ -298,11 +306,6 @@ nf_flow_table_iterate(struct nf_flowtable *flow_table,return err; } -static inline bool nf_flow_has_expired (const struct flow_offload *flow) -{ -return (__s32)(flow->timeout - (u32 )jiffies) <=0 ; -} -static void nf_flow_offload_gc_step (struct flow_offload *flow,void *data) {struct nf_flowtable *flow_table = data;
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 5/7 netfilter: nf_flow_table: teardown flow timeout race
In reply to Pablo Neira AyusoFlows that are in teardown state (due to RST / FIN TCP packet) still have their offload flag set on. Hence, the conntrack garbage collector may race to undo the timeout adjustment that the fixup routine performs, leaving the conntrack entry in place with the internal offload timeout (one day).
Update teardown flow state to ESTABLISHED and set tracking to liberal, then once the offload bit is cleared, adjust timeout if it is more than the default fixup timeout (conntrack might already have set a lower timeout from the packet path).
--- net/netfilter/nf_flow_table_core.c | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-)
net/netfilter/nf_flow_table_core.c +25 -9
@@ -111,15 +111,16 @@ static void flow_offload_fixup_tcp(struct ip_ct_tcp *tcp)#define NF_FLOWTABLE_TCP_PICKUP_TIMEOUT (120 * HZ)#define NF_FLOWTABLE_UDP_PICKUP_TIMEOUT (30 * HZ) -static void flow_offload_fixup_ct (struct nf_conn *ct) +static inline __s32 nf_flow_timeout_delta (unsigned int timeout) +{ +return (__s32)(timeout - (u32 )jiffies); +} + +static void flow_offload_fixup_ct_timeout (struct nf_conn *ct) {const struct nf_conntrack_l4proto *l4proto; +int l4num =nf_ct_protonum (ct);unsigned int timeout; -int l4num; - - l4num =nf_ct_protonum (ct); -if (l4num ==IPPROTO_TCP ) -flow_offload_fixup_tcp (&ct->proto.tcp); l4proto =nf_ct_l4proto_find (l4num);if (!l4proto)
@@ -132,7 +133,20 @@ static void flow_offload_fixup_ct(struct nf_conn *ct)else return ; - ct->timeout = nfct_time_stamp + timeout; +if (nf_flow_timeout_delta (ct->timeout) > (__s32 )timeout) + ct->timeout = nfct_time_stamp + timeout; +} + +static void flow_offload_fixup_ct_state (struct nf_conn *ct) +{ +if (nf_ct_protonum (ct) ==IPPROTO_TCP ) +flow_offload_fixup_tcp (&ct->proto.tcp); +} + +static void flow_offload_fixup_ct (struct nf_conn *ct) +{ +flow_offload_fixup_ct_state (ct); +flow_offload_fixup_ct_timeout (ct); }void flow_offload_free (struct flow_offload *flow)
@@ -210,7 +224,7 @@ EXPORT_SYMBOL_GPL(flow_offload_add);static inline bool nf_flow_has_expired (const struct flow_offload *flow) { -return (__s32)(flow->timeout - (u32 )jiffies) <=0 ; +return nf_flow_timeout_delta (flow->timeout) <=0 ; } static void flow_offload_del(struct nf_flowtable *flow_table,
@@ -230,6 +244,8 @@ static void flow_offload_del(struct nf_flowtable *flow_table,if (nf_flow_has_expired (flow))flow_offload_fixup_ct (e->ct); +else if (flow->flags &FLOW_OFFLOAD_TEARDOWN ) +flow_offload_fixup_ct_timeout (e->ct);flow_offload_free (flow); }
@@ -241,7 +257,7 @@ void flow_offload_teardown(struct flow_offload *flow) flow->flags |=FLOW_OFFLOAD_TEARDOWN ; e = container_of(flow, struct flow_offload_entry, flow); -flow_offload_fixup_ct (e->ct); +flow_offload_fixup_ct_state (e->ct); }EXPORT_SYMBOL_GPL (flow_offload_teardown);
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 6/7 netfilter: conntrack: Use consistent ct id hash calculation
In reply to Pablo Neira AyusoFrom: Dirk Morris <[email protected]>
Change ct id hash calculation to only use invariants.
Currently the ct id hash calculation is based on some fields that can change in the lifetime on a conntrack entry in some corner cases. The current hash uses the whole tuple which contains an hlist pointer which will change when the conntrack is placed on the dying list resulting in a ct id change.
This patch also removes the reply-side tuple and extension pointer from the hash calculation so that the ct id will will not change from initialization until confirmation.
--- net/netfilter/nf_conntrack_core.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
net/netfilter/nf_conntrack_core.c +8 -8
@@ -453,13 +453,12 @@ EXPORT_SYMBOL_GPL(nf_ct_invert_tuple);* table location, we assume id gets exposed to userspace. * * Following nf_conn items do not change throughout lifetime -* of the nf_conn after it has been committed to main hash table: +* of the nf_conn: * * 1. nf_conn address -* 2. nf_conn->ext address -* 3. nf_conn->master address (normally NULL) -* 4. tuple -* 5. the associated net namespace +* 2. nf_conn->master address (normally NULL) +* 3. the associated net namespace +* 4. the original direction tuple */ u32 nf_ct_get_id (const struct nf_conn *ct) {
@@ -469,9 +468,10 @@ u32 nf_ct_get_id(const struct nf_conn *ct)net_get_random_once (&ct_id_seed,sizeof (ct_id_seed)); a = (unsigned long )ct; - b = (unsigned long )ct->master ^net_hash_mix (nf_ct_net (ct)); - c = (unsigned long )ct->ext; - d = (unsigned long )siphash (&ct->tuplehash,sizeof (ct->tuplehash), + b = (unsigned long )ct->master; + c = (unsigned long )nf_ct_net (ct); + d = (unsigned long )siphash (&ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple, +sizeof (ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple), &ct_id_seed);#ifdef CONFIG_64BIT return siphash_4u64 ((u64 )a, (u64 )b, (u64 )c, (u64 )d, &ct_id_seed);
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 7/7 netfilter: nft_flow_offload: skip tcp rst and fin packets
In reply to Pablo Neira AyusoTCP rst and fin packets do not qualify to place a flow into the flowtable. Most likely there will be no more packets after connection closure. Without this patch, this flow entry expires and connection tracking picks up the entry in ESTABLISHED state using the fixup timeout, which makes this look inconsistent to the user for a connection that is actually already closed.
--- net/netfilter/nft_flow_offload.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
net/netfilter/nft_flow_offload.c +6 -3
@@ -72,11 +72,11 @@ static void nft_flow_offload_eval(const struct nft_expr *expr, {struct nft_flow_offload *priv =nft_expr_priv (expr);struct nf_flowtable *flowtable = &priv->flowtable->data; +struct tcphdr _tcph, *tcph =NULL ;enum ip_conntrack_info ctinfo;struct nf_flow_route route;struct flow_offload *flow;enum ip_conntrack_dir dir; -bool is_tcp = false;struct nf_conn *ct;int ret;
@@ -89,7 +89,10 @@ static void nft_flow_offload_eval(const struct nft_expr *expr,switch (ct->tuplehash[IP_CT_DIR_ORIGINAL ].tuple.dst.protonum) {case IPPROTO_TCP : - is_tcp = true; + tcph =skb_header_pointer (pkt->skb, pkt->xt.thoff, +sizeof (_tcph), &_tcph); +if (unlikely (!tcph || tcph->fin || tcph->rst)) + goto out;break ;case IPPROTO_UDP :break ;
@@ -115,7 +118,7 @@ static void nft_flow_offload_eval(const struct nft_expr *expr,if (!flow) goto err_flow_alloc; -if (is_tcp) { +if (tcph) { ct->proto.tcp.seen[0 ].flags |=IP_CT_TCP_FLAG_BE_LIBERAL ; ct->proto.tcp.seen[1 ].flags |=IP_CT_TCP_FLAG_BE_LIBERAL ; }
Signature · 1 line
2.11.0
David Miller
maintainerFrom: Pablo Neira Ayuso <[email protected]>
Date: Wed, 14 Aug 2019 11:24:33 +0200
Quoted 12 lines
This patchset contains Netfilter fixes for net:
1) Extend selftest to cover flowtable with ipsec, from Florian Westphal.
2) Fix interaction of ipsec with flowtable, also from Florian.
3) User-after-free with bound set to rule that fails to load.
4) Adjust state and timeout for flows that expire.
5) Timeout update race with flows in teardown state.
Quoted 8 lines
6) Ensure conntrack id hash calculation use invariants as input, from Dirk Morris.
7) Do not push flows into flowtable for TCP fin/rst packets.
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
Pulled, thanks.