From: Greg Kroah-Hartman Date: Sat, 5 Mar 2022 12:10:04 +0000 (+0100) Subject: 4.19-stable patches X-Git-Tag: v4.9.305~79 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=277bdbb7e0c60101af2097bd894360807d2a4f09;p=thirdparty%2Fkernel%2Fstable-queue.git 4.19-stable patches added patches: netfilter-fix-use-after-free-in-__nf_register_net_hook.patch netfilter-nf_queue-don-t-assume-sk-is-full-socket.patch netfilter-nf_queue-fix-possible-use-after-free.patch xfrm-enforce-validity-of-offload-input-flags.patch xfrm-fix-mtu-regression.patch xfrm-fix-the-if_id-check-in-changelink.patch --- diff --git a/queue-4.19/netfilter-fix-use-after-free-in-__nf_register_net_hook.patch b/queue-4.19/netfilter-fix-use-after-free-in-__nf_register_net_hook.patch new file mode 100644 index 00000000000..61bfe6c1dbc --- /dev/null +++ b/queue-4.19/netfilter-fix-use-after-free-in-__nf_register_net_hook.patch @@ -0,0 +1,141 @@ +From 56763f12b0f02706576a088e85ef856deacc98a0 Mon Sep 17 00:00:00 2001 +From: Eric Dumazet +Date: Sun, 27 Feb 2022 10:01:41 -0800 +Subject: netfilter: fix use-after-free in __nf_register_net_hook() + +From: Eric Dumazet + +commit 56763f12b0f02706576a088e85ef856deacc98a0 upstream. + +We must not dereference @new_hooks after nf_hook_mutex has been released, +because other threads might have freed our allocated hooks already. + +BUG: KASAN: use-after-free in nf_hook_entries_get_hook_ops include/linux/netfilter.h:130 [inline] +BUG: KASAN: use-after-free in hooks_validate net/netfilter/core.c:171 [inline] +BUG: KASAN: use-after-free in __nf_register_net_hook+0x77a/0x820 net/netfilter/core.c:438 +Read of size 2 at addr ffff88801c1a8000 by task syz-executor237/4430 + +CPU: 1 PID: 4430 Comm: syz-executor237 Not tainted 5.17.0-rc5-syzkaller-00306-g2293be58d6a1 #0 +Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 +Call Trace: + + __dump_stack lib/dump_stack.c:88 [inline] + dump_stack_lvl+0xcd/0x134 lib/dump_stack.c:106 + print_address_description.constprop.0.cold+0x8d/0x336 mm/kasan/report.c:255 + __kasan_report mm/kasan/report.c:442 [inline] + kasan_report.cold+0x83/0xdf mm/kasan/report.c:459 + nf_hook_entries_get_hook_ops include/linux/netfilter.h:130 [inline] + hooks_validate net/netfilter/core.c:171 [inline] + __nf_register_net_hook+0x77a/0x820 net/netfilter/core.c:438 + nf_register_net_hook+0x114/0x170 net/netfilter/core.c:571 + nf_register_net_hooks+0x59/0xc0 net/netfilter/core.c:587 + nf_synproxy_ipv6_init+0x85/0xe0 net/netfilter/nf_synproxy_core.c:1218 + synproxy_tg6_check+0x30d/0x560 net/ipv6/netfilter/ip6t_SYNPROXY.c:81 + xt_check_target+0x26c/0x9e0 net/netfilter/x_tables.c:1038 + check_target net/ipv6/netfilter/ip6_tables.c:530 [inline] + find_check_entry.constprop.0+0x7f1/0x9e0 net/ipv6/netfilter/ip6_tables.c:573 + translate_table+0xc8b/0x1750 net/ipv6/netfilter/ip6_tables.c:735 + do_replace net/ipv6/netfilter/ip6_tables.c:1153 [inline] + do_ip6t_set_ctl+0x56e/0xb90 net/ipv6/netfilter/ip6_tables.c:1639 + nf_setsockopt+0x83/0xe0 net/netfilter/nf_sockopt.c:101 + ipv6_setsockopt+0x122/0x180 net/ipv6/ipv6_sockglue.c:1024 + rawv6_setsockopt+0xd3/0x6a0 net/ipv6/raw.c:1084 + __sys_setsockopt+0x2db/0x610 net/socket.c:2180 + __do_sys_setsockopt net/socket.c:2191 [inline] + __se_sys_setsockopt net/socket.c:2188 [inline] + __x64_sys_setsockopt+0xba/0x150 net/socket.c:2188 + do_syscall_x64 arch/x86/entry/common.c:50 [inline] + do_syscall_64+0x35/0xb0 arch/x86/entry/common.c:80 + entry_SYSCALL_64_after_hwframe+0x44/0xae +RIP: 0033:0x7f65a1ace7d9 +Code: 28 00 00 00 75 05 48 83 c4 28 c3 e8 71 15 00 00 90 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b8 ff ff ff f7 d8 64 89 01 48 +RSP: 002b:00007f65a1a7f308 EFLAGS: 00000246 ORIG_RAX: 0000000000000036 +RAX: ffffffffffffffda RBX: 0000000000000006 RCX: 00007f65a1ace7d9 +RDX: 0000000000000040 RSI: 0000000000000029 RDI: 0000000000000003 +RBP: 00007f65a1b574c8 R08: 0000000000000001 R09: 0000000000000000 +R10: 0000000020000000 R11: 0000000000000246 R12: 00007f65a1b55130 +R13: 00007f65a1b574c0 R14: 00007f65a1b24090 R15: 0000000000022000 + + +The buggy address belongs to the page: +page:ffffea0000706a00 refcount:0 mapcount:0 mapping:0000000000000000 index:0x0 pfn:0x1c1a8 +flags: 0xfff00000000000(node=0|zone=1|lastcpupid=0x7ff) +raw: 00fff00000000000 ffffea0001c1b108 ffffea000046dd08 0000000000000000 +raw: 0000000000000000 0000000000000000 00000000ffffffff 0000000000000000 +page dumped because: kasan: bad access detected +page_owner tracks the page as freed +page last allocated via order 2, migratetype Unmovable, gfp_mask 0x52dc0(GFP_KERNEL|__GFP_NOWARN|__GFP_NORETRY|__GFP_COMP|__GFP_ZERO), pid 4430, ts 1061781545818, free_ts 1061791488993 + prep_new_page mm/page_alloc.c:2434 [inline] + get_page_from_freelist+0xa72/0x2f50 mm/page_alloc.c:4165 + __alloc_pages+0x1b2/0x500 mm/page_alloc.c:5389 + __alloc_pages_node include/linux/gfp.h:572 [inline] + alloc_pages_node include/linux/gfp.h:595 [inline] + kmalloc_large_node+0x62/0x130 mm/slub.c:4438 + __kmalloc_node+0x35a/0x4a0 mm/slub.c:4454 + kmalloc_node include/linux/slab.h:604 [inline] + kvmalloc_node+0x97/0x100 mm/util.c:580 + kvmalloc include/linux/slab.h:731 [inline] + kvzalloc include/linux/slab.h:739 [inline] + allocate_hook_entries_size net/netfilter/core.c:61 [inline] + nf_hook_entries_grow+0x140/0x780 net/netfilter/core.c:128 + __nf_register_net_hook+0x144/0x820 net/netfilter/core.c:429 + nf_register_net_hook+0x114/0x170 net/netfilter/core.c:571 + nf_register_net_hooks+0x59/0xc0 net/netfilter/core.c:587 + nf_synproxy_ipv6_init+0x85/0xe0 net/netfilter/nf_synproxy_core.c:1218 + synproxy_tg6_check+0x30d/0x560 net/ipv6/netfilter/ip6t_SYNPROXY.c:81 + xt_check_target+0x26c/0x9e0 net/netfilter/x_tables.c:1038 + check_target net/ipv6/netfilter/ip6_tables.c:530 [inline] + find_check_entry.constprop.0+0x7f1/0x9e0 net/ipv6/netfilter/ip6_tables.c:573 + translate_table+0xc8b/0x1750 net/ipv6/netfilter/ip6_tables.c:735 + do_replace net/ipv6/netfilter/ip6_tables.c:1153 [inline] + do_ip6t_set_ctl+0x56e/0xb90 net/ipv6/netfilter/ip6_tables.c:1639 + nf_setsockopt+0x83/0xe0 net/netfilter/nf_sockopt.c:101 +page last free stack trace: + reset_page_owner include/linux/page_owner.h:24 [inline] + free_pages_prepare mm/page_alloc.c:1352 [inline] + free_pcp_prepare+0x374/0x870 mm/page_alloc.c:1404 + free_unref_page_prepare mm/page_alloc.c:3325 [inline] + free_unref_page+0x19/0x690 mm/page_alloc.c:3404 + kvfree+0x42/0x50 mm/util.c:613 + rcu_do_batch kernel/rcu/tree.c:2527 [inline] + rcu_core+0x7b1/0x1820 kernel/rcu/tree.c:2778 + __do_softirq+0x29b/0x9c2 kernel/softirq.c:558 + +Memory state around the buggy address: + ffff88801c1a7f00: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff + ffff88801c1a7f80: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff +>ffff88801c1a8000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff + ^ + ffff88801c1a8080: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff + ffff88801c1a8100: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff + +Fixes: 2420b79f8c18 ("netfilter: debug: check for sorted array") +Signed-off-by: Eric Dumazet +Reported-by: syzbot +Acked-by: Florian Westphal +Signed-off-by: Pablo Neira Ayuso +Signed-off-by: Greg Kroah-Hartman +--- + net/netfilter/core.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +--- a/net/netfilter/core.c ++++ b/net/netfilter/core.c +@@ -335,14 +335,15 @@ static int __nf_register_net_hook(struct + p = nf_entry_dereference(*pp); + new_hooks = nf_hook_entries_grow(p, reg); + +- if (!IS_ERR(new_hooks)) ++ if (!IS_ERR(new_hooks)) { ++ hooks_validate(new_hooks); + rcu_assign_pointer(*pp, new_hooks); ++ } + + mutex_unlock(&nf_hook_mutex); + if (IS_ERR(new_hooks)) + return PTR_ERR(new_hooks); + +- hooks_validate(new_hooks); + #ifdef CONFIG_NETFILTER_INGRESS + if (pf == NFPROTO_NETDEV && reg->hooknum == NF_NETDEV_INGRESS) + net_inc_ingress_queue(); diff --git a/queue-4.19/netfilter-nf_queue-don-t-assume-sk-is-full-socket.patch b/queue-4.19/netfilter-nf_queue-don-t-assume-sk-is-full-socket.patch new file mode 100644 index 00000000000..0f303ab37ea --- /dev/null +++ b/queue-4.19/netfilter-nf_queue-don-t-assume-sk-is-full-socket.patch @@ -0,0 +1,52 @@ +From 747670fd9a2d1b7774030dba65ca022ba442ce71 Mon Sep 17 00:00:00 2001 +From: Florian Westphal +Date: Fri, 25 Feb 2022 14:02:41 +0100 +Subject: netfilter: nf_queue: don't assume sk is full socket + +From: Florian Westphal + +commit 747670fd9a2d1b7774030dba65ca022ba442ce71 upstream. + +There is no guarantee that state->sk refers to a full socket. + +If refcount transitions to 0, sock_put calls sk_free which then ends up +with garbage fields. + +I'd like to thank Oleksandr Natalenko and Jiri Benc for considerable +debug work and pointing out state->sk oddities. + +Fixes: ca6fb0651883 ("tcp: attach SYNACK messages to request sockets instead of listener") +Tested-by: Oleksandr Natalenko +Signed-off-by: Florian Westphal +Signed-off-by: Greg Kroah-Hartman +--- + net/netfilter/nf_queue.c | 11 ++++++++++- + 1 file changed, 10 insertions(+), 1 deletion(-) + +--- a/net/netfilter/nf_queue.c ++++ b/net/netfilter/nf_queue.c +@@ -46,6 +46,15 @@ void nf_unregister_queue_handler(struct + } + EXPORT_SYMBOL(nf_unregister_queue_handler); + ++static void nf_queue_sock_put(struct sock *sk) ++{ ++#ifdef CONFIG_INET ++ sock_gen_put(sk); ++#else ++ sock_put(sk); ++#endif ++} ++ + void nf_queue_entry_release_refs(struct nf_queue_entry *entry) + { + struct nf_hook_state *state = &entry->state; +@@ -56,7 +65,7 @@ void nf_queue_entry_release_refs(struct + if (state->out) + dev_put(state->out); + if (state->sk) +- sock_put(state->sk); ++ nf_queue_sock_put(state->sk); + #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) + if (entry->skb->nf_bridge) { + struct net_device *physdev; diff --git a/queue-4.19/netfilter-nf_queue-fix-possible-use-after-free.patch b/queue-4.19/netfilter-nf_queue-fix-possible-use-after-free.patch new file mode 100644 index 00000000000..8453e99d342 --- /dev/null +++ b/queue-4.19/netfilter-nf_queue-fix-possible-use-after-free.patch @@ -0,0 +1,98 @@ +From c3873070247d9e3c7a6b0cf9bf9b45e8018427b1 Mon Sep 17 00:00:00 2001 +From: Florian Westphal +Date: Mon, 28 Feb 2022 06:22:22 +0100 +Subject: netfilter: nf_queue: fix possible use-after-free + +From: Florian Westphal + +commit c3873070247d9e3c7a6b0cf9bf9b45e8018427b1 upstream. + +Eric Dumazet says: + The sock_hold() side seems suspect, because there is no guarantee + that sk_refcnt is not already 0. + +On failure, we cannot queue the packet and need to indicate an +error. The packet will be dropped by the caller. + +v2: split skb prefetch hunk into separate change + +Fixes: 271b72c7fa82c ("udp: RCU handling for Unicast packets.") +Reported-by: Eric Dumazet +Reviewed-by: Eric Dumazet +Signed-off-by: Florian Westphal +Signed-off-by: Greg Kroah-Hartman +--- + include/net/netfilter/nf_queue.h | 2 +- + net/netfilter/nf_queue.c | 11 +++++++++-- + net/netfilter/nfnetlink_queue.c | 12 +++++++++--- + 3 files changed, 19 insertions(+), 6 deletions(-) + +--- a/include/net/netfilter/nf_queue.h ++++ b/include/net/netfilter/nf_queue.h +@@ -32,7 +32,7 @@ void nf_register_queue_handler(struct ne + void nf_unregister_queue_handler(struct net *net); + void nf_reinject(struct nf_queue_entry *entry, unsigned int verdict); + +-void nf_queue_entry_get_refs(struct nf_queue_entry *entry); ++bool nf_queue_entry_get_refs(struct nf_queue_entry *entry); + void nf_queue_entry_release_refs(struct nf_queue_entry *entry); + + static inline void init_hashrandom(u32 *jhash_initval) +--- a/net/netfilter/nf_queue.c ++++ b/net/netfilter/nf_queue.c +@@ -82,10 +82,13 @@ void nf_queue_entry_release_refs(struct + EXPORT_SYMBOL_GPL(nf_queue_entry_release_refs); + + /* Bump dev refs so they don't vanish while packet is out */ +-void nf_queue_entry_get_refs(struct nf_queue_entry *entry) ++bool nf_queue_entry_get_refs(struct nf_queue_entry *entry) + { + struct nf_hook_state *state = &entry->state; + ++ if (state->sk && !refcount_inc_not_zero(&state->sk->sk_refcnt)) ++ return false; ++ + if (state->in) + dev_hold(state->in); + if (state->out) +@@ -104,6 +107,7 @@ void nf_queue_entry_get_refs(struct nf_q + dev_hold(physdev); + } + #endif ++ return true; + } + EXPORT_SYMBOL_GPL(nf_queue_entry_get_refs); + +@@ -195,7 +199,10 @@ static int __nf_queue(struct sk_buff *sk + .size = sizeof(*entry) + route_key_size, + }; + +- nf_queue_entry_get_refs(entry); ++ if (!nf_queue_entry_get_refs(entry)) { ++ kfree(entry); ++ return -ENOTCONN; ++ } + + switch (entry->state.pf) { + case AF_INET: +--- a/net/netfilter/nfnetlink_queue.c ++++ b/net/netfilter/nfnetlink_queue.c +@@ -716,9 +716,15 @@ static struct nf_queue_entry * + nf_queue_entry_dup(struct nf_queue_entry *e) + { + struct nf_queue_entry *entry = kmemdup(e, e->size, GFP_ATOMIC); +- if (entry) +- nf_queue_entry_get_refs(entry); +- return entry; ++ ++ if (!entry) ++ return NULL; ++ ++ if (nf_queue_entry_get_refs(entry)) ++ return entry; ++ ++ kfree(entry); ++ return NULL; + } + + #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) diff --git a/queue-4.19/series b/queue-4.19/series index b56709feb23..c64647482e4 100644 --- a/queue-4.19/series +++ b/queue-4.19/series @@ -14,3 +14,9 @@ usb-gadget-clear-related-members-when-goto-fail.patch ata-pata_hpt37x-fix-pci-clock-detection.patch alsa-intel_hdmi-fix-reference-to-pcm-buffer-address.patch asoc-ops-shift-tested-values-in-snd_soc_put_volsw-by-min.patch +xfrm-fix-mtu-regression.patch +netfilter-fix-use-after-free-in-__nf_register_net_hook.patch +xfrm-fix-the-if_id-check-in-changelink.patch +xfrm-enforce-validity-of-offload-input-flags.patch +netfilter-nf_queue-don-t-assume-sk-is-full-socket.patch +netfilter-nf_queue-fix-possible-use-after-free.patch diff --git a/queue-4.19/xfrm-enforce-validity-of-offload-input-flags.patch b/queue-4.19/xfrm-enforce-validity-of-offload-input-flags.patch new file mode 100644 index 00000000000..77488fb63db --- /dev/null +++ b/queue-4.19/xfrm-enforce-validity-of-offload-input-flags.patch @@ -0,0 +1,65 @@ +From 7c76ecd9c99b6e9a771d813ab1aa7fa428b3ade1 Mon Sep 17 00:00:00 2001 +From: Leon Romanovsky +Date: Tue, 8 Feb 2022 16:14:32 +0200 +Subject: xfrm: enforce validity of offload input flags + +From: Leon Romanovsky + +commit 7c76ecd9c99b6e9a771d813ab1aa7fa428b3ade1 upstream. + +struct xfrm_user_offload has flags variable that received user input, +but kernel didn't check if valid bits were provided. It caused a situation +where not sanitized input was forwarded directly to the drivers. + +For example, XFRM_OFFLOAD_IPV6 define that was exposed, was used by +strongswan, but not implemented in the kernel at all. + +As a solution, check and sanitize input flags to forward +XFRM_OFFLOAD_INBOUND to the drivers. + +Fixes: d77e38e612a0 ("xfrm: Add an IPsec hardware offloading API") +Signed-off-by: Leon Romanovsky +Signed-off-by: Steffen Klassert +Signed-off-by: Greg Kroah-Hartman +--- + include/uapi/linux/xfrm.h | 6 ++++++ + net/xfrm/xfrm_device.c | 6 +++++- + 2 files changed, 11 insertions(+), 1 deletion(-) + +--- a/include/uapi/linux/xfrm.h ++++ b/include/uapi/linux/xfrm.h +@@ -504,6 +504,12 @@ struct xfrm_user_offload { + int ifindex; + __u8 flags; + }; ++/* This flag was exposed without any kernel code that supporting it. ++ * Unfortunately, strongswan has the code that uses sets this flag, ++ * which makes impossible to reuse this bit. ++ * ++ * So leave it here to make sure that it won't be reused by mistake. ++ */ + #define XFRM_OFFLOAD_IPV6 1 + #define XFRM_OFFLOAD_INBOUND 2 + +--- a/net/xfrm/xfrm_device.c ++++ b/net/xfrm/xfrm_device.c +@@ -153,6 +153,9 @@ int xfrm_dev_state_add(struct net *net, + if (x->encap || x->tfcpad) + return -EINVAL; + ++ if (xuo->flags & ~(XFRM_OFFLOAD_IPV6 | XFRM_OFFLOAD_INBOUND)) ++ return -EINVAL; ++ + dev = dev_get_by_index(net, xuo->ifindex); + if (!dev) { + if (!(xuo->flags & XFRM_OFFLOAD_INBOUND)) { +@@ -190,7 +193,8 @@ int xfrm_dev_state_add(struct net *net, + + xso->dev = dev; + xso->num_exthdrs = 1; +- xso->flags = xuo->flags; ++ /* Don't forward bit that is not implemented */ ++ xso->flags = xuo->flags & ~XFRM_OFFLOAD_IPV6; + + err = dev->xfrmdev_ops->xdo_dev_state_add(x); + if (err) { diff --git a/queue-4.19/xfrm-fix-mtu-regression.patch b/queue-4.19/xfrm-fix-mtu-regression.patch new file mode 100644 index 00000000000..cc9f2e34412 --- /dev/null +++ b/queue-4.19/xfrm-fix-mtu-regression.patch @@ -0,0 +1,79 @@ +From 6596a0229541270fb8d38d989f91b78838e5e9da Mon Sep 17 00:00:00 2001 +From: Jiri Bohac +Date: Wed, 19 Jan 2022 10:22:53 +0100 +Subject: xfrm: fix MTU regression + +From: Jiri Bohac + +commit 6596a0229541270fb8d38d989f91b78838e5e9da upstream. + +Commit 749439bfac6e1a2932c582e2699f91d329658196 ("ipv6: fix udpv6 +sendmsg crash caused by too small MTU") breaks PMTU for xfrm. + +A Packet Too Big ICMPv6 message received in response to an ESP +packet will prevent all further communication through the tunnel +if the reported MTU minus the ESP overhead is smaller than 1280. + +E.g. in a case of a tunnel-mode ESP with sha256/aes the overhead +is 92 bytes. Receiving a PTB with MTU of 1371 or less will result +in all further packets in the tunnel dropped. A ping through the +tunnel fails with "ping: sendmsg: Invalid argument". + +Apparently the MTU on the xfrm route is smaller than 1280 and +fails the check inside ip6_setup_cork() added by 749439bf. + +We found this by debugging USGv6/ipv6ready failures. Failing +tests are: "Phase-2 Interoperability Test Scenario IPsec" / +5.3.11 and 5.4.11 (Tunnel Mode: Fragmentation). + +Commit b515d2637276a3810d6595e10ab02c13bfd0b63a ("xfrm: +xfrm_state_mtu should return at least 1280 for ipv6") attempted +to fix this but caused another regression in TCP MSS calculations +and had to be reverted. + +The patch below fixes the situation by dropping the MTU +check and instead checking for the underflows described in the +749439bf commit message. + +Signed-off-by: Jiri Bohac +Fixes: 749439bfac6e ("ipv6: fix udpv6 sendmsg crash caused by too small MTU") +Signed-off-by: Steffen Klassert +Signed-off-by: Greg Kroah-Hartman +--- + net/ipv6/ip6_output.c | 11 +++++++---- + 1 file changed, 7 insertions(+), 4 deletions(-) + +--- a/net/ipv6/ip6_output.c ++++ b/net/ipv6/ip6_output.c +@@ -1259,8 +1259,6 @@ static int ip6_setup_cork(struct sock *s + if (np->frag_size) + mtu = np->frag_size; + } +- if (mtu < IPV6_MIN_MTU) +- return -EINVAL; + cork->base.fragsize = mtu; + cork->base.gso_size = ipc6->gso_size; + cork->base.tx_flags = 0; +@@ -1320,8 +1318,6 @@ static int __ip6_append_data(struct sock + + fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len + + (opt ? opt->opt_nflen : 0); +- maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen - +- sizeof(struct frag_hdr); + + headersize = sizeof(struct ipv6hdr) + + (opt ? opt->opt_flen + opt->opt_nflen : 0) + +@@ -1329,6 +1325,13 @@ static int __ip6_append_data(struct sock + sizeof(struct frag_hdr) : 0) + + rt->rt6i_nfheader_len; + ++ if (mtu < fragheaderlen || ++ ((mtu - fragheaderlen) & ~7) + fragheaderlen < sizeof(struct frag_hdr)) ++ goto emsgsize; ++ ++ maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen - ++ sizeof(struct frag_hdr); ++ + /* as per RFC 7112 section 5, the entire IPv6 Header Chain must fit + * the first fragment + */ diff --git a/queue-4.19/xfrm-fix-the-if_id-check-in-changelink.patch b/queue-4.19/xfrm-fix-the-if_id-check-in-changelink.patch new file mode 100644 index 00000000000..dec28a32676 --- /dev/null +++ b/queue-4.19/xfrm-fix-the-if_id-check-in-changelink.patch @@ -0,0 +1,36 @@ +From 6d0d95a1c2b07270870e7be16575c513c29af3f1 Mon Sep 17 00:00:00 2001 +From: Antony Antony +Date: Tue, 1 Feb 2022 07:51:57 +0100 +Subject: xfrm: fix the if_id check in changelink + +From: Antony Antony + +commit 6d0d95a1c2b07270870e7be16575c513c29af3f1 upstream. + +if_id will be always 0, because it was not yet initialized. + +Fixes: 8dce43919566 ("xfrm: interface with if_id 0 should return error") +Reported-by: Pavel Machek +Signed-off-by: Antony Antony +Signed-off-by: Steffen Klassert +Signed-off-by: Greg Kroah-Hartman +--- + net/xfrm/xfrm_interface.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/net/xfrm/xfrm_interface.c ++++ b/net/xfrm/xfrm_interface.c +@@ -698,12 +698,12 @@ static int xfrmi_changelink(struct net_d + struct net *net = xi->net; + struct xfrm_if_parms p = {}; + ++ xfrmi_netlink_parms(data, &p); + if (!p.if_id) { + NL_SET_ERR_MSG(extack, "if_id must be non zero"); + return -EINVAL; + } + +- xfrmi_netlink_parms(data, &p); + xi = xfrmi_locate(net, &p); + if (!xi) { + xi = netdev_priv(dev);