From cbd86e4598955a03053f31bb4c1ea05f5ddd0560 Mon Sep 17 00:00:00 2001 From: eabdullin Date: Thu, 14 May 2026 14:26:19 +0300 Subject: [PATCH] Bump version to 5.14.0-611.54.5 net: skbuff: propagate shared-frag marker through frag-transfer helpers Replace 611.54.4's partial fix (which was a backport of Hyunwoo Kim's v1 patch covering only __pskb_copy_fclone() and skb_try_coalesce()) with a backport of the upstream v3 patch: https://lore.kernel.org/all/agW4vC0r8QOUKtRT@v4bel/ v3 also covers skb_shift() (the new hunk added in v2) and skb_gro_receive() / skb_gro_receive_list() (the audit follow-up suggested by Sultan Alsawaf in agVpIsaSherjHTYg@sultan-box). All five sites moved frag descriptors between skbs without propagating the SKBFL_SHARED_FRAG marker, so destinations could end up referencing externally-owned or page-cache-backed pages while reporting skb_has_shared_frag() as false. Combined with ESP-over-UDP and UDP GRO, or any nf_dup_ipv4 / xt_TEE caller, this lets an unprivileged user trigger in-place ESP decryption over root-owned page-cache pages (CVE-2026-46300, "Fragnesia"). Tree-adapted: skb_gro_receive_list() is still a static helper in net/ipv4/udp_offload.c on RHEL 9 (not promoted to a global GRO helper in net/core/gro.c as in upstream v3); skb_shift() still uses the open-coded skb->len -= shiftlen block instead of skb_len_add(). --- ...-skbuff-propagate-shared-frag-marker.patch | 107 ++++++++++++++---- SPECS/kernel.spec | 7 +- 2 files changed, 87 insertions(+), 27 deletions(-) diff --git a/SOURCES/1102-net-skbuff-propagate-shared-frag-marker.patch b/SOURCES/1102-net-skbuff-propagate-shared-frag-marker.patch index cecaf98dd..849b2be32 100644 --- a/SOURCES/1102-net-skbuff-propagate-shared-frag-marker.patch +++ b/SOURCES/1102-net-skbuff-propagate-shared-frag-marker.patch @@ -1,28 +1,30 @@ -From: Andrew Lukoshko -Subject: [PATCH AlmaLinux 9] net: skbuff: propagate shared-frag marker through pskb_copy() +From: Eduard Abdullin +Subject: [PATCH AlmaLinux 9] net: skbuff: propagate shared-frag marker through frag-transfer helpers -Backport of upstream patch posted at -https://lore.kernel.org/all/agRfuVOeMI5pbHhY@v4bel/ -(sibling to the xfrm/esp shared-frag fix already shipped as -1100-xfrm-esp-avoid-in-place-decrypt-shared-skb-frags.patch in -5.14.0-611.54.2). +Backport of upstream v3 patch posted at +https://lore.kernel.org/all/agW4vC0r8QOUKtRT@v4bel/ +(sibling to upstream commit f4c50a4034e6 "xfrm: esp: avoid in-place +decrypt on shared skb frags"). -__pskb_copy_fclone() shallow-copies the source's frag descriptors and -bumps each page's refcount via skb_frag_ref(), then defers the rest -of the shinfo metadata to skb_copy_header(). That helper only carries -over gso_{size,segs,type} and never touches skb_shinfo()->flags, so -the destination skb keeps a reference to the same externally-owned or -page-cache-backed pages while reporting skb_has_shared_frag() as -false. +Three frag-transfer helpers in net/core/skbuff.c +(__pskb_copy_fclone(), skb_try_coalesce(), skb_shift()) and the +GRO accumulator path in net/core/gro.c (skb_gro_receive()) and the +UDP GRO list helper in net/ipv4/udp_offload.c +(skb_gro_receive_list(), kept as a static helper on AlmaLinux 9) +fail to propagate the SKBFL_SHARED_FRAG bit in skb_shinfo()->flags +when moving frag descriptors from source to destination. As a +result, the destination skb keeps a reference to the same +externally-owned or page-cache-backed pages while reporting +skb_has_shared_frag() as false. The mismatch is harmful in any in-place writer that uses skb_has_shared_frag() to decide whether shared pages must be detoured through skb_cow_data(). ESP input is one such writer (esp4.c, -esp6.c), and a single nft 'dup to ' rule -- or any other -nf_dup_ipv4() / xt_TEE caller -- is enough to land a pskb_copy()'d -skb in esp_input() with the marker stripped, letting an unprivileged -user write into the page cache of a root-owned read-only file via -authencesn-ESN stray writes. +esp6.c). Combined with an nft 'dup to ' rule, an +nf_dup_ipv4() / xt_TEE caller, or ESP-over-UDP with UDP GRO, this +lets an unprivileged user write into the page cache of a root-owned +read-only file via authencesn-ESN stray writes (CVE-2026-46300, +"Fragnesia"). Set SKBFL_SHARED_FRAG on the destination whenever frag descriptors were actually moved from the source. skb_copy() and skb_copy_expand() @@ -30,18 +32,53 @@ share skb_copy_header() too but linearize all paged data into freshly allocated head storage and emerge with nr_frags == 0, so skb_has_shared_frag() returns false on its own; they need no change. -Verified to apply with `patch -p1 -F0` (no offset, no fuzz, no rejects) -against kernel-5.14.0-611.54.1.el9_7. +The same omission exists in skb_gro_receive() and +skb_gro_receive_list(). The former moves the incoming skb's frag +descriptors into the accumulator's last sub-skb via two paths plus a +"merge:" fallback that chains the whole skb onto frag_list; the +latter chains the incoming skb whole onto p's frag_list. Downstream +skb_segment() reads only skb_shinfo(p)->flags, and skb_segment_list() +reuses each sub-skb's shinfo as the nskb -- both p and lp must carry +the marker. + +Tree adaptation: + * Upstream v3 places skb_gro_receive_list() in net/core/gro.c. + AlmaLinux 9 still keeps it as a static helper in + net/ipv4/udp_offload.c (it has not been promoted to a global + GRO helper in this tree). Apply the propagation hunk there + instead. + * Upstream skb_shift() uses skb_len_add() helpers (introduced in + v5.16); AlmaLinux 9 still has the open-coded + `skb->len -= shiftlen; ...` block. The insertion point (right + after both ip_summed assignments) is the same. Fixes: cef401de7be8 ("net: fix possible wrong checksum generation") Fixes: f4c50a4034e6 ("xfrm: esp: avoid in-place decrypt on shared skb frags") +Reported-by: Sultan Alsawaf Reported-by: William Bowling Reported-by: Hyunwoo Kim -Signed-off-by: Andrew Lukoshko +Signed-off-by: Eduard Abdullin --- - net/core/skbuff.c | 3 +++ - 1 file changed, 3 insertions(+) + net/core/gro.c | 2 ++ + net/core/skbuff.c | 6 ++++++ + net/ipv4/udp_offload.c | 2 ++ + 3 files changed, 10 insertions(+) +--- a/net/core/gro.c ++++ b/net/core/gro.c +@@ -222,10 +222,12 @@ int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb) + p->data_len += len; + p->truesize += delta_truesize; + p->len += len; ++ skb_shinfo(p)->flags |= skbinfo->flags & SKBFL_SHARED_FRAG; + if (lp != p) { + lp->data_len += len; + lp->truesize += delta_truesize; + lp->len += len; ++ skb_shinfo(lp)->flags |= skbinfo->flags & SKBFL_SHARED_FRAG; + } + NAPI_GRO_CB(skb)->same_flow = 1; + return 0; --- a/net/core/skbuff.c +++ b/net/core/skbuff.c @@ -2026,6 +2026,7 @@ struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom, @@ -52,7 +89,16 @@ Signed-off-by: Andrew Lukoshko } if (skb_has_frag_list(skb)) { -@@ -5740,6 +5741,8 @@ bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from, +@@ -4029,6 +4030,8 @@ int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen) + tgt->ip_summed = CHECKSUM_PARTIAL; + skb->ip_summed = CHECKSUM_PARTIAL; + ++ skb_shinfo(tgt)->flags |= skb_shinfo(skb)->flags & SKBFL_SHARED_FRAG; ++ + /* Yak, is it really working this way? Some helper please? */ + skb->len -= shiftlen; + skb->data_len -= shiftlen; +@@ -5740,6 +5743,8 @@ bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from, from_shinfo->frags, from_shinfo->nr_frags * sizeof(skb_frag_t)); to_shinfo->nr_frags += from_shinfo->nr_frags; @@ -61,5 +107,16 @@ Signed-off-by: Andrew Lukoshko if (!skb_cloned(from)) from_shinfo->nr_frags = 0; +--- a/net/ipv4/udp_offload.c ++++ b/net/ipv4/udp_offload.c +@@ -487,6 +487,8 @@ static int skb_gro_receive_list(struct sk_buff *p, struct sk_buff *skb) + p->truesize += skb->truesize; + p->len += skb->len; + ++ skb_shinfo(p)->flags |= skb_shinfo(skb)->flags & SKBFL_SHARED_FRAG; ++ + NAPI_GRO_CB(skb)->same_flow = 1; + + return 0; -- 2.43.0 diff --git a/SPECS/kernel.spec b/SPECS/kernel.spec index ffa16124e..18b2b4918 100644 --- a/SPECS/kernel.spec +++ b/SPECS/kernel.spec @@ -165,13 +165,13 @@ Summary: The Linux kernel # define buildid .local %define specversion 5.14.0 %define patchversion 5.14 -%define pkgrelease 611.54.4 +%define pkgrelease 611.54.5 %define kversion 5 %define tarfile_release 5.14.0-611.54.1.el9_7 # This is needed to do merge window version magic %define patchlevel 14 # This allows pkg_release to have configurable %%{?dist} tag -%define specrelease 611.54.4%{?buildid}%{?dist} +%define specrelease 611.54.5%{?buildid}%{?dist} # This defines the kabi tarball version %define kabiversion 5.14.0-611.54.1.el9_7 @@ -3777,6 +3777,9 @@ fi # # %changelog +* Thu May 14 2026 Eduard Abdullin - 5.14.0-611.54.5 +- net: skbuff: propagate shared-frag marker through frag-transfer helpers + * Wed May 13 2026 Andrew Lukoshko - 5.14.0-611.54.4 - net: skbuff: propagate shared-frag marker through pskb_copy()