Netfilter fixes for net
Subsystems (3)
Pablo Neira Ayuso
maintainercover Netfilter fixes for net
Hi,
The following patchset contains Netfilter fixes for net:
1) Fix missing overflow use refcount checks in nf_tables.
2) Do not set IPS_ASSURED for IPS_NAT_CLASH entries in GRE tracker, from Florian Westphal.
3) Bail out if nf_ct_helper_hash is NULL before registering helper, from Florent Revest.
4) Use siphash() instead siphash_4u64() to fix performance regression, also from Florian.
5) Do not allow to add rules to removed chains via ID, from Thadeu Lima de Souza Cascardo.
6) Fix oob read access in byteorder expression, also from Thadeu.
Please, pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf.git nf-23-07-06
Thanks.
----------------------------------------------------------------
The following changes since commit c451410ca7e3d8eeb31d141fc20c200e21754ba4:
Merge branch 'mptcp-fixes' (2023-07-05 10:51:14 +0100)
are available in the Git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf.git tags/nf-23-07-06
for you to fetch changes up to caf3ef7468f7534771b5c44cd8dbd6f7f87c2cbd:
netfilter: nf_tables: prevent OOB access in nft_byteorder_eval (2023-07-06 00:53:14 +0200)
----------------------------------------------------------------
netfilter pull request 23-07-06
----------------------------------------------------------------
Florent Revest (1):
netfilter: conntrack: Avoid nf_ct_helper_hash uses after free
Florian Westphal (2):
netfilter: conntrack: gre: don't set assured flag for clash entries
netfilter: conntrack: don't fold port numbers into addresses before hashing
Pablo Neira Ayuso (1):
netfilter: nf_tables: report use refcount overflow
Thadeu Lima de Souza Cascardo (2):
netfilter: nf_tables: do not ignore genmask when looking up chain by id
netfilter: nf_tables: prevent OOB access in nft_byteorder_eval
include/net/netfilter/nf_conntrack_tuple.h | 3 + include/net/netfilter/nf_tables.h | 31 ++++- net/netfilter/nf_conntrack_core.c | 20 ++-- net/netfilter/nf_conntrack_helper.c | 4 + net/netfilter/nf_conntrack_proto_gre.c | 10 +- net/netfilter/nf_tables_api.c | 174 ++++++++++++++++++----------- net/netfilter/nft_byteorder.c | 14 +-- net/netfilter/nft_flow_offload.c | 6 +- net/netfilter/nft_immediate.c | 8 +- net/netfilter/nft_objref.c | 8 +- 10 files changed, 178 insertions(+), 100 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/6 netfilter: nf_tables: report use refcount overflow
Overflow use refcount checks are not complete.
Add helper function to deal with object reference counter tracking. Report -EMFILE in case UINT_MAX is reached.
nft_use_dec() splats in case that reference counter underflows, which should not ever happen.
Add nft_use_inc_restore() and nft_use_dec_restore() which are used to restore reference counter from error and abort paths.
Use u32 in nft_flowtable and nft_object since helper functions cannot work on bitfields.
Remove the few early incomplete checks now that the helper functions are in place and used to check for refcount overflow.
--- include/net/netfilter/nf_tables.h | 31 +++++- net/netfilter/nf_tables_api.c | 163 ++++++++++++++++++------------ net/netfilter/nft_flow_offload.c | 6 +- net/netfilter/nft_immediate.c | 8 +- net/netfilter/nft_objref.c | 8 +- 5 files changed, 141 insertions(+), 75 deletions(-)
include/net/netfilter/nf_tables.h +27 -4
@@ -1211,6 +1211,29 @@ int __nft_release_basechain(struct nft_ctx *ctx);unsigned int nft_do_chain (struct nft_pktinfo *pkt,void *priv); +static inline bool nft_use_inc (u32 *use) +{ +if (*use ==UINT_MAX ) +return false; + + (*use)++; + +return true; +} + +static inline void nft_use_dec (u32 *use) +{ +WARN_ON_ONCE ((*use)-- ==0 ); +} + +/* For error and abort path: restore use counter to previous state. */ +static inline void nft_use_inc_restore (u32 *use) +{ +WARN_ON_ONCE (!nft_use_inc (use)); +} + +#define nft_use_dec_restore nft_use_dec +/** * struct nft_table - nf_tables table *
@@ -1296,8 +1319,8 @@ struct nft_object {struct list_head list;struct rhlist_head rhlhead;struct nft_object_hash_key key; - u32 genmask:2, - use:30; + u32 genmask:2; +u32 use;u64 handle;u16 udlen;u8 *udata;
@@ -1399,8 +1422,8 @@ struct nft_flowtable {char *name;int hooknum;int ops_len; - u32 genmask:2, - use:30; + u32 genmask:2; +u32 use;u64 handle;/* runtime data below here */ struct list_head hook_list____cacheline_aligned ;
net/netfilter/nf_tables_api.c +101 -62
508 lines not on this page · raw message
net/netfilter/nft_flow_offload.c +4 -2
@@ -408,8 +408,10 @@ static int nft_flow_offload_init(const struct nft_ctx *ctx,if (IS_ERR (flowtable))return PTR_ERR (flowtable); +if (!nft_use_inc (&flowtable->use)) +return -EMFILE ; + priv->flowtable = flowtable; - flowtable->use++;return nf_ct_netns_get (ctx->net, ctx->family); }
@@ -428,7 +430,7 @@ static void nft_flow_offload_activate(const struct nft_ctx *ctx, {struct nft_flow_offload *priv =nft_expr_priv (expr); - priv->flowtable->use++; +nft_use_inc_restore (&priv->flowtable->use); } static void nft_flow_offload_destroy(const struct nft_ctx *ctx,
net/netfilter/nft_immediate.c +4 -4
@@ -159,7 +159,7 @@ static void nft_immediate_deactivate(const struct nft_ctx *ctx,default :nft_chain_del (chain); chain->bound = false; - chain->table->use--; +nft_use_dec (&chain->table->use);break ; }break ;
@@ -198,7 +198,7 @@ static void nft_immediate_destroy(const struct nft_ctx *ctx,* let the transaction records release this chain and its rules. */ if (chain->bound) { - chain->use--; +nft_use_dec (&chain->use);break ; }
@@ -206,9 +206,9 @@ static void nft_immediate_destroy(const struct nft_ctx *ctx, chain_ctx = *ctx; chain_ctx.chain = chain; - chain->use--; +nft_use_dec (&chain->use);list_for_each_entry_safe (rule, n, &chain->rules, list) { - chain->use--; +nft_use_dec (&chain->use);list_del (&rule->list);nf_tables_rule_destroy (&chain_ctx, rule); }
net/netfilter/nft_objref.c +5 -3
@@ -41,8 +41,10 @@ static int nft_objref_init(const struct nft_ctx *ctx,if (IS_ERR (obj))return -ENOENT ; +if (!nft_use_inc (&obj->use)) +return -EMFILE ; +nft_objref_priv (expr) = obj; - obj->use++;return 0 ; }
@@ -72,7 +74,7 @@ static void nft_objref_deactivate(const struct nft_ctx *ctx,if (phase ==NFT_TRANS_COMMIT )return ; - obj->use--; +nft_use_dec (&obj->use); } static void nft_objref_activate(const struct nft_ctx *ctx,
@@ -80,7 +82,7 @@ static void nft_objref_activate(const struct nft_ctx *ctx, {struct nft_object *obj =nft_objref_priv (expr); - obj->use++; +nft_use_inc_restore (&obj->use); }static const struct nft_expr_ops nft_objref_ops = {
Signature · 1 line
2.30.2
Paolo Abeni
maintainerRe: [PATCH net 1/6] netfilter: nf_tables: report use refcount overflow
Quoted 7 lines · Pablo Neira Ayuso
Overflow use refcount checks are not complete.
Add helper function to deal with object reference counter tracking. Report
-EMFILEin caseUINT_MAXis reached.
nft_use_dec()splats in case that reference counter underflows, which should not ever happen.
For the records, I also once had the need for an non atomic reference counters implementing sanity checks on underflows/overflows. I resorted to use plain refcount_t, since the atomic op overhead was not noticeable in my use-case.
[not blocking this series, just thinking aloud] I'm wondering if a generic, non-atomic refcounter infra could be useful?
Cheers,
Paolo
Re: [PATCH net 1/6] netfilter: nf_tables: report use refcount overflow
In reply to Pablo Neira AyusoThis series was applied to netdev/net.git (main) by Pablo Neira Ayuso <[email protected]>:
Hello:
This series was applied to netdev/net.git (main)
by Pablo Neira Ayuso <[email protected]>:
Quoted 9 lines · On Thu, 6 Jul 2023 01:04:01 +0200 you wrote:
Overflow use refcount checks are not complete.
Add helper function to deal with object reference counter tracking. Report
-EMFILEin caseUINT_MAXis reached.
nft_use_dec()splats in case that reference counter underflows, which should not ever happen.[...]
Here is the summary with links:
- [net,1/6] netfilter: nf_tables: report use refcount overflow
https://git.kernel.org/netdev/net/c/1689f25924ad - [net,2/6] netfilter: conntrack: gre: don't set assured flag for clash entries https://git.kernel.org/netdev/net/c/8a9dc07ba924 - [net,3/6] netfilter: conntrack: Avoid nf_ct_helper_hash uses after free https://git.kernel.org/netdev/net/c/6eef7a2b9338 - [net,4/6] netfilter: conntrack: don't fold port numbers into addresses before hashing https://git.kernel.org/netdev/net/c/eaf9e7192ec9 - [net,5/6] netfilter: nf_tables: do not ignore genmask when looking up chain by id https://git.kernel.org/netdev/net/c/515ad530795c - [net,6/6] netfilter: nf_tables: prevent OOB access in nft_byteorder_eval https://git.kernel.org/netdev/net/c/caf3ef7468f7
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Pablo Neira Ayuso
maintainerPATCH 2/6 netfilter: conntrack: gre: don't set assured flag for clash entries
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
Now that conntrack core is allowd to insert clashing entries, make sure GRE won't set assured flag on NAT_CLASH entries, just like UDP.
Doing so prevents early_drop logic for these entries.
--- net/netfilter/nf_conntrack_proto_gre.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
net/netfilter/nf_conntrack_proto_gre.c +9 -1
@@ -205,6 +205,8 @@ int nf_conntrack_gre_packet(struct nf_conn *ct,enum ip_conntrack_info ctinfo, const struct nf_hook_state *state) { + unsigned long status; +if (!nf_ct_is_confirmed (ct)) {unsigned int *timeouts =nf_ct_timeout_lookup (ct);
@@ -217,11 +219,17 @@ int nf_conntrack_gre_packet(struct nf_conn *ct, ct->proto.gre.timeout = timeouts[GRE_CT_UNREPLIED ]; } + status =READ_ONCE (ct->status);/* If we've seen traffic both ways, this is a GRE connection. * Extend timeout. */ -if (ct->status &IPS_SEEN_REPLY ) { +if (status &IPS_SEEN_REPLY ) {nf_ct_refresh_acct (ct, ctinfo, skb, ct->proto.gre.stream_timeout); + +/* never set ASSURED for IPS_NAT_CLASH, they time out soon */ +if (unlikely ((status &IPS_NAT_CLASH ))) +return NF_ACCEPT ; +/* Also, more likely to be important, and not a probe. */ if (!test_and_set_bit (IPS_ASSURED_BIT , &ct->status))nf_conntrack_event_cache (IPCT_ASSURED , ct);
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 3/6 netfilter: conntrack: Avoid nf_ct_helper_hash uses after free
In reply to Pablo Neira AyusoFrom: Florent Revest <[email protected]>
If nf_conntrack_init_start() fails (for example due to a register_nf_conntrack_bpf() failure), the nf_conntrack_helper_fini() clean-up path frees the nf_ct_helper_hash map.
When built with NF_CONNTRACK=y, further netfilter modules (e.g:netfilter_conntrack_ftp) can still be loaded and call nf_conntrack_helpers_register(), independently of whether nf_conntrack initialized correctly. This accesses the nf_ct_helper_hash dangling pointer and causes a uaf, possibly leading to random memory corruption.
This patch guards nf_conntrack_helper_register() from accessing a freed or uninitialized nf_ct_helper_hash pointer and fixes possible uses-after-free when loading a conntrack module.
--- net/netfilter/nf_conntrack_helper.c | 4 ++++ 1 file changed, 4 insertions(+)
net/netfilter/nf_conntrack_helper.c +4 -0
@@ -360,6 +360,9 @@ int nf_conntrack_helper_register(struct nf_conntrack_helper *me)BUG_ON (me->expect_class_max >=NF_CT_MAX_EXPECT_CLASSES );BUG_ON (strlen (me->name) >NF_CT_HELPER_NAME_LEN -1 ); +if (!nf_ct_helper_hash) +return -ENOENT ; +if (me->expect_policy->max_expected >NF_CT_EXPECT_MAX_CNT )return -EINVAL ;
@@ -515,4 +518,5 @@ int nf_conntrack_helper_init(void)void nf_conntrack_helper_fini (void ) {kvfree (nf_ct_helper_hash); + nf_ct_helper_hash =NULL ; }
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 4/6 netfilter: conntrack: don't fold port numbers into addresses before hashing
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
Originally this used jhash2() over tuple and folded the zone id, the pernet hash value, destination port and l4 protocol number into the 32bit seed value.
When the switch to siphash was done, I used an on-stack temporary buffer to build a suitable key to be hashed via siphash().
But this showed up as performance regression, so I got rid of the temporary copy and collected to-be-hashed data in 4 u64 variables.
This makes it easy to build tuples that produce the same hash, which isn't desirable even though chain lengths are limited.
Switch back to plain siphash, but just like with jhash2(), take advantage of the fact that most of to-be-hashed data is already in a suitable order.
Use an empty struct as annotation in 'struct nf_conntrack_tuple' to mark last member that can be used as hash input.
The only remaining data that isn't present in the tuple structure are the zone identifier and the pernet hash: fold those into the key.
--- include/net/netfilter/nf_conntrack_tuple.h | 3 +++ net/netfilter/nf_conntrack_core.c | 20 +++++++------------- 2 files changed, 10 insertions(+), 13 deletions(-)
include/net/netfilter/nf_conntrack_tuple.h +3 -0
@@ -67,6 +67,9 @@ struct nf_conntrack_tuple {/* The protocol. */ u_int8_t protonum; +/* The direction must be ignored for the tuplehash */ +struct { } __nfct_hash_offsetend; +/* The direction (for tuplehash) */ u_int8_t dir; } dst;
net/netfilter/nf_conntrack_core.c +7 -13
@@ -211,24 +211,18 @@ static u32 hash_conntrack_raw(const struct nf_conntrack_tuple *tuple,unsigned int zoneid, const struct net *net) { - u64 a, b, c, d; + siphash_key_t key;get_random_once (&nf_conntrack_hash_rnd,sizeof (nf_conntrack_hash_rnd)); -/* The direction must be ignored, handle usable tuplehash members manually */ - a = (u64 )tuple->src.u3.all[0 ] <<32 | tuple->src.u3.all[3 ]; - b = (u64 )tuple->dst.u3.all[0 ] <<32 | tuple->dst.u3.all[3 ]; + key = nf_conntrack_hash_rnd; - c = (__force u64 )tuple->src.u.all <<32 | (__force u64 )tuple->dst.u.all <<16 ; - c |= tuple->dst.protonum; + key.key[0 ] ^= zoneid; + key.key[1 ] ^=net_hash_mix (net); - d = (u64 )zoneid <<32 |net_hash_mix (net); - -/* IPv4: u3.all[1,2,3] == 0 */ - c ^= (u64 )tuple->src.u3.all[1 ] <<32 | tuple->src.u3.all[2 ]; - d += (u64 )tuple->dst.u3.all[1 ] <<32 | tuple->dst.u3.all[2 ]; - -return (u32 )siphash_4u64 (a, b, c, d, &nf_conntrack_hash_rnd); +return siphash ((void *)tuple, + offsetofend(struct nf_conntrack_tuple, dst.__nfct_hash_offsetend), + &key); }static u32 scale_hash (u32 hash)
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 5/6 netfilter: nf_tables: do not ignore genmask when looking up chain by id
In reply to Pablo Neira AyusoFrom: Thadeu Lima de Souza Cascardo <[email protected]>
When adding a rule to a chain referring to its ID, if that chain had been deleted on the same batch, the rule might end up referring to a deleted chain.
This will lead to a WARNING like following:
[ 33.098431] ------------[ cut here ]------------ [ 33.098678] WARNING: CPU: 5 PID: 69 at net/netfilter/nf_tables_api.c:2037 nf_tables_chain_destroy+0x23d/0x260 [ 33.099217] Modules linked in: [ 33.099388] CPU: 5 PID: 69 Comm: kworker/5:1 Not tainted 6.4.0+ #409 [ 33.099726] Workqueue: events nf_tables_trans_destroy_work [ 33.100018] RIP: 0010:nf_tables_chain_destroy+0x23d/0x260 [ 33.100306] Code: 8b 7c 24 68 e8 64 9c ed fe 4c 89 e7 e8 5c 9c ed fe 48 83 c4 08 5b 41 5c 41 5d 41 5e 41 5f 5d 31 c0 89 c6 89 c7 c3 cc cc cc cc <0f> 0b 48 83 c4 08 5b 41 5c 41 5d 41 5e 41 5f 5d 31 c0 89 c6 89 c7 [ 33.101271] RSP: 0018:ffffc900004ffc48 EFLAGS: 00010202 [ 33.101546] RAX: 0000000000000001 RBX: ffff888006fc0a28 RCX: 0000000000000000 [ 33.101920] RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000 [ 33.102649] RBP: ffffc900004ffc78 R08: 0000000000000000 R09: 0000000000000000 [ 33.103018] R10: 0000000000000000 R11: 0000000000000000 R12: ffff8880135ef500 [ 33.103385] R13: 0000000000000000 R14: dead000000000122 R15: ffff888006fc0a10 [ 33.103762] FS: 0000000000000000(0000) GS:ffff888024c80000(0000) knlGS:0000000000000000 [ 33.104184] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 33.104493] CR2: 00007fe863b56a50 CR3: 00000000124b0001 CR4: 0000000000770ee0 [ 33.104872] PKRU: 55555554 [ 33.104999] Call Trace: [ 33.105113] <TASK> [ 33.105214] ? show_regs+0x72/0x90 [ 33.105371] ? __warn+0xa5/0x210 [ 33.105520] ? nf_tables_chain_destroy+0x23d/0x260 [ 33.105732] ? report_bug+0x1f2/0x200 [ 33.105902] ? handle_bug+0x46/0x90 [ 33.106546] ? exc_invalid_op+0x19/0x50 [ 33.106762] ? asm_exc_invalid_op+0x1b/0x20 [ 33.106995] ? nf_tables_chain_destroy+0x23d/0x260 [ 33.107249] ? nf_tables_chain_destroy+0x30/0x260 [ 33.107506] nf_tables_trans_destroy_work+0x669/0x680 [ 33.107782] ? mark_held_locks+0x28/0xa0 [ 33.107996] ? __pfx_nf_tables_trans_destroy_work+0x10/0x10 [ 33.108294] ? _raw_spin_unlock_irq+0x28/0x70 [ 33.108538] process_one_work+0x68c/0xb70 [ 33.108755] ? lock_acquire+0x17f/0x420 [ 33.108977] ? __pfx_process_one_work+0x10/0x10 [ 33.109218] ? do_raw_spin_lock+0x128/0x1d0 [ 33.109435] ? _raw_spin_lock_irq+0x71/0x80 [ 33.109634] worker_thread+0x2bd/0x700 [ 33.109817] ? __pfx_worker_thread+0x10/0x10 [ 33.110254] kthread+0x18b/0x1d0 [ 33.110410] ? __pfx_kthread+0x10/0x10 [ 33.110581] ret_from_fork+0x29/0x50 [ 33.110757] </TASK> [ 33.110866] irq event stamp: 1651 [ 33.111017] hardirqs last enabled at (1659): [<ffffffffa206a209>] __up_console_sem+0x79/0xa0 [ 33.111379] hardirqs last disabled at (1666): [<ffffffffa206a1ee>] __up_console_sem+0x5e/0xa0 [ 33.111740] softirqs last enabled at (1616): [<ffffffffa1f5d40e>] __irq_exit_rcu+0x9e/0xe0 [ 33.112094] softirqs last disabled at (1367): [<ffffffffa1f5d40e>] __irq_exit_rcu+0x9e/0xe0 [ 33.112453] ---[ end trace 0000000000000000 ]---
This is due to the nft_chain_lookup_byid ignoring the genmask. After this change, adding the new rule will fail as it will not find the chain.
--- net/netfilter/nf_tables_api.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
net/netfilter/nf_tables_api.c +7 -4
@@ -2699,7 +2699,7 @@ static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy,static struct nft_chain *nft_chain_lookup_byid (const struct net *net,const struct nft_table *table, -const struct nlattr *nla) +const struct nlattr *nla,u8 genmask) {struct nftables_pernet *nft_net =nft_pernet (net);u32 id =ntohl (nla_get_be32 (nla));
@@ -2710,7 +2710,8 @@ static struct nft_chain *nft_chain_lookup_byid(const struct net *net,if (trans->msg_type ==NFT_MSG_NEWCHAIN && chain->table == table && - id ==nft_trans_chain_id (trans)) + id ==nft_trans_chain_id (trans) && +nft_active_genmask (chain, genmask))return chain; }return ERR_PTR (-ENOENT );
@@ -3814,7 +3815,8 @@ static int nf_tables_newrule(struct sk_buff *skb, const struct nfnl_info *info,return -EOPNOTSUPP ; }else if (nla[NFTA_RULE_CHAIN_ID ]) { - chain =nft_chain_lookup_byid (net, table, nla[NFTA_RULE_CHAIN_ID ]); + chain =nft_chain_lookup_byid (net, table, nla[NFTA_RULE_CHAIN_ID ], + genmask);if (IS_ERR (chain)) {NL_SET_BAD_ATTR (extack, nla[NFTA_RULE_CHAIN_ID ]);return PTR_ERR (chain);
@@ -10540,7 +10542,8 @@ static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data, genmask); }else if (tb[NFTA_VERDICT_CHAIN_ID ]) { chain =nft_chain_lookup_byid (ctx->net, ctx->table, - tb[NFTA_VERDICT_CHAIN_ID ]); + tb[NFTA_VERDICT_CHAIN_ID ], + genmask);if (IS_ERR (chain))return PTR_ERR (chain); }else {
Signature · 1 line
2.30.2
Pablo Neira Ayuso
maintainerPATCH 6/6 netfilter: nf_tables: prevent OOB access in nft_byteorder_eval
In reply to Pablo Neira AyusoFrom: Thadeu Lima de Souza Cascardo <[email protected]>
When evaluating byteorder expressions with size 2, a union with 32-bit and 16-bit members is used. Since the 16-bit members are aligned to 32-bit, the array accesses will be out-of-bounds.
It may lead to a stack-out-of-bounds access like the one below:
[ 23.095215] ================================================================== [ 23.095625] BUG: KASAN: stack-out-of-bounds in nft_byteorder_eval+0x13c/0x320 [ 23.096020] Read of size 2 at addr ffffc90000007948 by task ping/115 [ 23.096358] [ 23.096456] CPU: 0 PID: 115 Comm: ping Not tainted 6.4.0+ #413 [ 23.096770] Call Trace: [ 23.096910] <IRQ> [ 23.097030] dump_stack_lvl+0x60/0xc0 [ 23.097218] print_report+0xcf/0x630 [ 23.097388] ? nft_byteorder_eval+0x13c/0x320 [ 23.097577] ? kasan_addr_to_slab+0xd/0xc0 [ 23.097760] ? nft_byteorder_eval+0x13c/0x320 [ 23.097949] kasan_report+0xc9/0x110 [ 23.098106] ? nft_byteorder_eval+0x13c/0x320 [ 23.098298] __asan_load2+0x83/0xd0 [ 23.098453] nft_byteorder_eval+0x13c/0x320 [ 23.098659] nft_do_chain+0x1c8/0xc50 [ 23.098852] ? __pfx_nft_do_chain+0x10/0x10 [ 23.099078] ? __kasan_check_read+0x11/0x20 [ 23.099295] ? __pfx___lock_acquire+0x10/0x10 [ 23.099535] ? __pfx___lock_acquire+0x10/0x10 [ 23.099745] ? __kasan_check_read+0x11/0x20 [ 23.099929] nft_do_chain_ipv4+0xfe/0x140 [ 23.100105] ? __pfx_nft_do_chain_ipv4+0x10/0x10 [ 23.100327] ? lock_release+0x204/0x400 [ 23.100515] ? nf_hook.constprop.0+0x340/0x550 [ 23.100779] nf_hook_slow+0x6c/0x100 [ 23.100977] ? __pfx_nft_do_chain_ipv4+0x10/0x10 [ 23.101223] nf_hook.constprop.0+0x334/0x550 [ 23.101443] ? __pfx_ip_local_deliver_finish+0x10/0x10 [ 23.101677] ? __pfx_nf_hook.constprop.0+0x10/0x10 [ 23.101882] ? __pfx_ip_rcv_finish+0x10/0x10 [ 23.102071] ? __pfx_ip_local_deliver_finish+0x10/0x10 [ 23.102291] ? rcu_read_lock_held+0x4b/0x70 [ 23.102481] ip_local_deliver+0xbb/0x110 [ 23.102665] ? __pfx_ip_rcv+0x10/0x10 [ 23.102839] ip_rcv+0x199/0x2a0 [ 23.102980] ? __pfx_ip_rcv+0x10/0x10 [ 23.103140] __netif_receive_skb_one_core+0x13e/0x150 [ 23.103362] ? __pfx___netif_receive_skb_one_core+0x10/0x10 [ 23.103647] ? mark_held_locks+0x48/0xa0 [ 23.103819] ? process_backlog+0x36c/0x380 [ 23.103999] __netif_receive_skb+0x23/0xc0 [ 23.104179] process_backlog+0x91/0x380 [ 23.104350] __napi_poll.constprop.0+0x66/0x360 [ 23.104589] ? net_rx_action+0x1cb/0x610 [ 23.104811] net_rx_action+0x33e/0x610 [ 23.105024] ? _raw_spin_unlock+0x23/0x50 [ 23.105257] ? __pfx_net_rx_action+0x10/0x10 [ 23.105485] ? mark_held_locks+0x48/0xa0 [ 23.105741] __do_softirq+0xfa/0x5ab [ 23.105956] ? __dev_queue_xmit+0x765/0x1c00 [ 23.106193] do_softirq.part.0+0x49/0xc0 [ 23.106423] </IRQ> [ 23.106547] <TASK> [ 23.106670] __local_bh_enable_ip+0xf5/0x120 [ 23.106903] __dev_queue_xmit+0x789/0x1c00 [ 23.107131] ? __pfx___dev_queue_xmit+0x10/0x10 [ 23.107381] ? find_held_lock+0x8e/0xb0 [ 23.107585] ? lock_release+0x204/0x400 [ 23.107798] ? neigh_resolve_output+0x185/0x350 [ 23.108049] ? mark_held_locks+0x48/0xa0 [ 23.108265] ? neigh_resolve_output+0x185/0x350 [ 23.108514] neigh_resolve_output+0x246/0x350 [ 23.108753] ? neigh_resolve_output+0x246/0x350 [ 23.109003] ip_finish_output2+0x3c3/0x10b0 [ 23.109250] ? __pfx_ip_finish_output2+0x10/0x10 [ 23.109510] ? __pfx_nf_hook+0x10/0x10 [ 23.109732] __ip_finish_output+0x217/0x390 [ 23.109978] ip_finish_output+0x2f/0x130 [ 23.110207] ip_output+0xc9/0x170 [ 23.110404] ip_push_pending_frames+0x1a0/0x240 [ 23.110652] raw_sendmsg+0x102e/0x19e0 [ 23.110871] ? __pfx_raw_sendmsg+0x10/0x10 [ 23.111093] ? lock_release+0x204/0x400 [ 23.111304] ? __mod_lruvec_page_state+0x148/0x330 [ 23.111567] ? find_held_lock+0x8e/0xb0 [ 23.111777] ? find_held_lock+0x8e/0xb0 [ 23.111993] ? __rcu_read_unlock+0x7c/0x2f0 [ 23.112225] ? aa_sk_perm+0x18a/0x550 [ 23.112431] ? filemap_map_pages+0x4f1/0x900 [ 23.112665] ? __pfx_aa_sk_perm+0x10/0x10 [ 23.112880] ? find_held_lock+0x8e/0xb0 [ 23.113098] inet_sendmsg+0xa0/0xb0 [ 23.113297] ? inet_sendmsg+0xa0/0xb0 [ 23.113500] ? __pfx_inet_sendmsg+0x10/0x10 [ 23.113727] sock_sendmsg+0xf4/0x100 [ 23.113924] ? move_addr_to_kernel.part.0+0x4f/0xa0 [ 23.114190] __sys_sendto+0x1d4/0x290 [ 23.114391] ? __pfx___sys_sendto+0x10/0x10 [ 23.114621] ? __pfx_mark_lock.part.0+0x10/0x10 [ 23.114869] ? lock_release+0x204/0x400 [ 23.115076] ? find_held_lock+0x8e/0xb0 [ 23.115287] ? rcu_is_watching+0x23/0x60 [ 23.115503] ? __rseq_handle_notify_resume+0x6e2/0x860 [ 23.115778] ? __kasan_check_write+0x14/0x30 [ 23.116008] ? blkcg_maybe_throttle_current+0x8d/0x770 [ 23.116285] ? mark_held_locks+0x28/0xa0 [ 23.116503] ? do_syscall_64+0x37/0x90 [ 23.116713] __x64_sys_sendto+0x7f/0xb0 [ 23.116924] do_syscall_64+0x59/0x90 [ 23.117123] ? irqentry_exit_to_user_mode+0x25/0x30 [ 23.117387] ? irqentry_exit+0x77/0xb0 [ 23.117593] ? exc_page_fault+0x92/0x140 [ 23.117806] entry_SYSCALL_64_after_hwframe+0x6e/0xd8 [ 23.118081] RIP: 0033:0x7f744aee2bba [ 23.118282] Code: d8 64 89 02 48 c7 c0 ff ff ff ff eb b8 0f 1f 00 f3 0f 1e fa 41 89 ca 64 8b 04 25 18 00 00 00 85 c0 75 15 b8 2c 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 7e c3 0f 1f 44 00 00 41 54 48 83 ec 30 44 89 [ 23.119237] RSP: 002b:00007ffd04a7c9f8 EFLAGS: 00000246 ORIG_RAX: 000000000000002c [ 23.119644] RAX: ffffffffffffffda RBX: 00007ffd04a7e0a0 RCX: 00007f744aee2bba [ 23.120023] RDX: 0000000000000040 RSI: 000056488e9e6300 RDI: 0000000000000003 [ 23.120413] RBP: 000056488e9e6300 R08: 00007ffd04a80320 R09: 0000000000000010 [ 23.120809] R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000040 [ 23.121219] R13: 00007ffd04a7dc38 R14: 00007ffd04a7ca00 R15: 00007ffd04a7e0a0 [ 23.121617] </TASK> [ 23.121749] [ 23.121845] The buggy address belongs to the virtual mapping at [ 23.121845] [ffffc90000000000, ffffc90000009000) created by: [ 23.121845] irq_init_percpu_irqstack+0x1cf/0x270 [ 23.122707] [ 23.122803] The buggy address belongs to the physical page: [ 23.123104] page:0000000072ac19f0 refcount:1 mapcount:0 mapping:0000000000000000 index:0x0 pfn:0x24a09 [ 23.123609] flags: 0xfffffc0001000(reserved|node=0|zone=1|lastcpupid=0x1fffff) [ 23.123998] page_type: 0xffffffff() [ 23.124194] raw: 000fffffc0001000 ffffea0000928248 ffffea0000928248 0000000000000000 [ 23.124610] raw: 0000000000000000 0000000000000000 00000001ffffffff 0000000000000000 [ 23.125023] page dumped because: kasan: bad access detected [ 23.125326] [ 23.125421] Memory state around the buggy address: [ 23.125682] ffffc90000007800: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [ 23.126072] ffffc90000007880: 00 00 00 00 00 f1 f1 f1 f1 f1 f1 00 00 f2 f2 00 [ 23.126455] >ffffc90000007900: 00 00 00 00 00 00 00 00 00 f2 f2 f2 f2 00 00 00 [ 23.126840] ^ [ 23.127138] ffffc90000007980: 00 00 00 00 00 00 00 00 00 00 00 00 00 f3 f3 f3 [ 23.127522] ffffc90000007a00: f3 00 00 00 00 00 00 00 00 00 00 00 f1 f1 f1 f1 [ 23.127906] ================================================================== [ 23.128324] Disabling lock debugging due to kernel taint
Using simple s16 pointers for the 16-bit accesses fixes the problem. For the 32-bit accesses, src and dst can be used directly.
--- net/netfilter/nft_byteorder.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
net/netfilter/nft_byteorder.c +7 -7
@@ -30,11 +30,11 @@ void nft_byteorder_eval(const struct nft_expr *expr,const struct nft_byteorder *priv =nft_expr_priv (expr);u32 *src = ®s->data[priv->sreg];u32 *dst = ®s->data[priv->dreg]; -union {u32 u32;u16 u16; } *s, *d; +u16 *s16, *d16;unsigned int i; - s = (void *)src; - d = (void *)dst; + s16 = (void *)src; + d16 = (void *)dst;switch (priv->size) {case 8 : {
@@ -62,11 +62,11 @@ void nft_byteorder_eval(const struct nft_expr *expr,switch (priv->op) {case NFT_BYTEORDER_NTOH :for (i =0 ; i < priv->len /4 ; i++) - d[i].u32 =ntohl ((__force __be32 )s[i].u32); + dst[i] =ntohl ((__force __be32 )src[i]);break ;case NFT_BYTEORDER_HTON :for (i =0 ; i < priv->len /4 ; i++) - d[i].u32 = (__force __u32 )htonl (s[i].u32); + dst[i] = (__force __u32 )htonl (src[i]);break ; }break ;
@@ -74,11 +74,11 @@ void nft_byteorder_eval(const struct nft_expr *expr,switch (priv->op) {case NFT_BYTEORDER_NTOH :for (i =0 ; i < priv->len /2 ; i++) - d[i].u16 =ntohs ((__force __be16 )s[i].u16); + d16[i] =ntohs ((__force __be16 )s16[i]);break ;case NFT_BYTEORDER_HTON :for (i =0 ; i < priv->len /2 ; i++) - d[i].u16 = (__force __u16 )htons (s[i].u16); + d16[i] = (__force __u16 )htons (s16[i]);break ; }break ;
Signature · 1 line
2.30.2