CVE-2026-43500: rxrpc: Also unshare DATA/RESPONSE packets when paged frags are present
In the Linux kernel, the following vulnerability has been resolved:
rxrpc: Also unshare DATA/RESPONSE packets when paged frags are present
The DATA-packet handler in rxrpc_input_call_event() and the RESPONSE
handler in rxrpc_verify_response() copy the skb to a linear one before
calling into the security ops only when skb_cloned() is true. An skb
that is not cloned but still carries externally-owned paged fragments
(e.g. SKBFL_SHARED_FRAG set by splice() into a UDP socket via
__ip_append_data, or a chained skb_has_frag_list()) falls through to
the in-place decryption path, which binds the frag pages directly into
the AEAD/skcipher SGL via skb_to_sgvec().
Extend the gate to also unshare when skb_has_frag_list() or
skb_has_shared_frag() is true. This catches the splice-loopback vector
and other externally-shared frag sources while preserving the
zero-copy fast path for skbs whose frags are kernel-private (e.g. NIC
page_pool RX, GRO). The OOM/trace handling already in place is reused.
Security readout for executives and security teams
Plain-English summary
A local, low-privileged user may trigger unsafe Linux kernel handling of shared packet-memory fragments in RxRPC. Successful exploitation could corrupt protected memory and affect confidentiality, integrity, and availability. This is high severity, but the supplied evidence does not show remote exploitation or confirmed attacks in the wild.
Executive priority
Prioritize prompt assessment and patching, especially on shared or multi-tenant Linux systems. This is not presented as an internet-remote vulnerability, but local low-privileged access may be enough. Escalate systems combining untrusted users, affected kernels, and RxRPC use; track vendor determinations where version status remains unclear.
Technical view
RxRPC DATA and RESPONSE processing could decrypt in place when an skb was not cloned but still referenced externally owned paged fragments. Those pages were placed directly into the cryptographic scatter-gather list, permitting writes into shared memory. The fix also unshares packets with fragment lists or shared fragments before security operations.
Likely exposure
Exposure requires an affected Linux kernel, local low-privileged access, and a reachable RxRPC processing path involving shared or chained paged fragments. The supplied affected-version data is ambiguous, so kernel builds and distribution advisories must be checked individually. The CVSS vector rates this as local, low complexity, low privileges, and no user interaction.
Exploitation context
A public repository is referenced and tagged as an exploit, indicating technical reproduction material may exist. However, the source bundle reports no CISA KEV listing and provides no evidence of active exploitation. Treat exploit maturity as uncertain rather than assuming attacks are occurring.
Researcher notes
The vulnerable gate relied only on skb_cloned(). Shared fragments introduced through splice-related UDP handling or chained fragment lists could therefore reach in-place cryptographic processing. Stable fixes extend the copy/unshare condition to skb_has_frag_list() and skb_has_shared_frag(), while retaining zero-copy handling for kernel-private fragments. The bundle does not establish exploit reliability or affected distribution packages.
Mitigation direction
Install the distribution or vendor kernel update containing the applicable stable fix.
Check Linux and distribution advisories for exact affected and corrected kernel builds.
Prioritize multi-user systems where untrusted users can obtain local access.
Restrict unnecessary local accounts and workloads until affected systems are updated.
Validation and detection
Inventory running kernel builds across Linux systems.
Compare each build against vendor advisories and the cited stable fixes.
Confirm updated systems booted into the corrected kernel, not an older installed build.
Review whether exposed systems use RxRPC and permit untrusted local access.
Generated from the cited source records. This long-tail analysis has not been individually reviewed by a named human.
Potential ATT&CK relevance
Conservative CVE-to-ATT&CK context
These mappings and lookup hints may be relevant to the vulnerability behavior, CWE, affected product, or exposure path. Glexia-inferred context is not an official MITRE, ATT&CK, CWE, or CVE Program mapping.
ATT&CK lookup starting points
Use these exact CWE pages and searches to review the Glexia ATT&CK library from this CVE's weakness and description context.
cwe · low confidence lookup
CWE-123: Exact CWE lookup
Use the exact CWE identifier as the starting point before reviewing related ATT&CK behavior. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
Use the exact CWE identifier as the starting point before reviewing related ATT&CK behavior. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
These fields come from the CVE record and ADP containers, not from Glexia's Take. They preserve time-varying source decisions such as CISA SSVC, KEV status, CVSS metrics, and provider references.
3CVSS vectors
5Timeline events
2ADP providers
10Source links
SSVC decision data
CISA-ADPCISA Coordinator
Timestamp
Version
2.0.3
Exploitation: noneAutomatable: noTechnical Impact: total
CVSS vector scores
3 official scores
We collect every scored CVSS vector available in the official CNA and ADP containers. When more than one version is present, the table keeps the source vectors side by side instead of collapsing them into the highest score.
CWE links open Glexia weakness intelligence pages with official CWE context, developer remediation guidance, and related CVE mappings.
CWE-123 · source CWE mapping
Write-what-where Condition
Write-what-where Condition represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.
Out-of-bounds Write represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.