EUVD-2026-108926
GHSA-cvm8-2x36-72mp
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach PFCP UDP listener on tunnel endpoint
-
ExploitSend short packet with S flag set
-
ExecutionTrigger out-of-bounds SEID read past packet data
-
ImpactLeak adjacent memory into flower classification metadata
Vulnerability Assessment
| Exploitation Conditions | The host must have the pfcp kernel module loaded and be configured as a PFCP encapsulation/tunnel device receiving PFCP-over-UDP traffic - i.e. a 5G/mobile-core or GTP control-plane role, not a default Linux configuration. Given that, no authentication or user interaction is required: the attacker simply sends a PFCP packet with the S flag set that is too short to actually contain the 8-byte SEID, or whose session header lies in a skb fragment rather than the linear area, so pfcp_session_recv() reads past the validated 4-byte PFCP header. The decisive limiting factor is deployment: on any system not running pfcp as a tunnel endpoint the vulnerable code path is never reached, which is why the ubiquitous-kernel footprint overstates real exposure. |
| Impact | The signals pull in opposite directions. The CVSS 3.1 base score of 7.3 is driven almost entirely by the unauthenticated network vector (AV:N/AC:L/PR:N/UI:N), which on its face suggests a remotely reachable, no-privilege flaw. The mitigating real-world signals, however, dominate: EPSS is only 0.21% (10th percentile), the CVE is NOT on the CISA KEV list, and the input contains no PoC or exploit reference - only the upstream kernel.org fix commits and the NVD link - so this is 'no public exploit identified at time of analysis.' Critically, the technical impact is an out-of-bounds READ that leaks a small amount of adjacent memory into tunnel metadata used by the flower classifier; it is an information-disclosure/classification-integrity issue, not remote code execution. The CVSS network vector is also misleading about reachability: it does not capture that the host must be acting as a PFCP (Packet Forwarding Control Protocol) tunnel endpoint - the pfcp module must be loaded and an encap device configured - which is a 5G/mobile-core/GTP scenario absent from the vast majority of Linux systems. The vuln.today 'this_week' decision label reflects a patch-available kernel info-leak worth scheduling, not an emergency. Net assessment: genuine but low real-world risk for general fleets and a narrowly scoped patch-this-cycle item only for operators actually running PFCP tunnels. |
| Exploit ScenarioDerived | An attacker who can send UDP traffic to a Linux host configured as a PFCP tunnel endpoint sends a crafted short PFCP packet with the S (session) flag set, or one whose session header falls in a non-linear fragment. pfcp_session_recv() reads the 8-byte SEID past the end of the validated linear data, and the out-of-bounds bytes are stored in tunnel metadata that the flower classifier then acts on, disclosing adjacent memory contents. No public exploit code is identified at time of analysis, and the attack is only possible against hosts running the pfcp module as a tunnel device. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
An out-of-bounds read in the Linux kernel's PFCP receive path lets a remote, unauthenticated sender make pfcp_session_recv() read past the validated packet data by sending a PFCP packet with the S flag set that is too short to hold the 8-byte SEID, or whose session header sits in a fragment rather than the linear area. Bytes read out of bounds are stored in the tunnel metadata that the flower classifier later matches on, giving limited confidentiality and integrity impact (vendor CVSS 7.3; assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N). Exposure is gated by deployment: the pfcp module must be loaded and the host must act as a PFCP tunnel endpoint, so default kernels are not reachable; EPSS is 0.21% (10th percentile) and no public exploit code was identified at the time of analysis, though the vendor classifies the fix as a this-week priority.
RemediationAI
Update to a kernel containing the fix: Linux 6.12.113, 6.18.57, 7.2.11 or 7.3 as applicable to your branch, or cherry-pick the corresponding stable commit listed above; the vendor marks patch availability and vuln.today classifies the update as this-week priority despite the low EPSS score, because the affected role is security-sensitive. Where an immediate kernel upgrade is not possible, the effective compensating control is to remove the attack surface rather than harden it generically: if the host is not a PFCP tunnel endpoint, do not load the pfcp module - unload it with rmmod pfcp and blacklist it so it is not auto-loaded - accepting that PFCP tunnel offload and the associated flower classification on PFCP session metadata become unavailable. If the host genuinely terminates PFCP traffic, that option is not viable and the kernel update is the complete fix; in that case restrict which peers can reach the PFCP listener to the trusted control-plane endpoints that legitimately send N4 traffic, understanding that this is a topology-level reduction of the exposed sender set and not a fix for the parsing defect, and that it cannot stop a spoofed or compromised legitimate peer. Verify the reloaded module version against the fixed branch after patching, since distribution kernels may backport the change without a version bump.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
PFCP (Packet Forwarding Control Protocol) is the 3GPP control protocol used between 5G session management and user plane functions; the kernel pfcp module provides an encapsulation/tunnel netdevice so received PFCP session headers, including the 64-bit Session Endpoint Identifier (SEID), can be exported into skb tunnel metadata for later classification by the flower tc classifier. The root cause is incomplete skb linearisation: pfcp_encap_recv() only calls pskb_may_pull() for the UDP header plus the 4-byte PFCP header, but when the S flag is set, pfcp_session_recv() reads the following 8-byte SEID without any corresponding pull, so a truncated packet or one whose session header lands in a fragment causes a read beyond the end of the packet data. The fix pulls up to the end of the SEID and drops packets too short to contain it, reloads the header pointer after pskb_may_pull() because it may reallocate the skb head, and uses offsetofend() instead of sizeof(struct pfcphdr_session) - the structure is not packed and its in-memory size is 16 bytes due to alignment of the __be64 member while the on-wire header is only 12 bytes, so the naive size check would have dropped valid session messages. No CWE identifier was supplied, and the precise trigger beyond the short-packet and fragmented-session-header cases is described only as above.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L
Remote unauthenticated PFCP packet (AV:N/AC:L/PR:N/UI:N) triggers a small OOB read leaking adjacent memory (C:L) that corrupts flower classification metadata (I:L); an OOB read of a few bytes within allocated skb memory is unlikely to crash (A:N).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
pfcp: make sure the SEID is linear before reading it
pfcp_encap_recv() only makes sure that the UDP header and the 4 byte PFCP header are in the linear area. When the S flag is set, pfcp_session_recv() then reads the 8 byte SEID that follows, which is not covered by the pskb_may_pull() check.
A short PFCP packet with the S flag set, or one whose session header lies in a fragment, therefore makes pfcp_session_recv() read beyond the end of the packet data, and whatever it finds there is stored in the tunnel metadata that flower later classifies on.
Pull up to the end of the SEID before reading it, and drop packets that are too short to contain it. Reload the header pointer afterwards since pskb_may_pull() may reallocate the skb head.
Use offsetofend() rather than sizeof(struct pfcphdr_session): the structure is not packed, so its size is 16 bytes because of the alignment of the __be64 member, while the header on the wire is only 12 bytes, and valid session messages would be dropped.
Executive ViewAI
A high-severity vulnerability in the Linux kernel's PFCP networking module could allow a remote unauthenticated attacker to read limited out-of-bounds memory and manipulate tunnel metadata, potentially leading to minor confidentiality and integrity breaches. Only organizations that have loaded the pfcp module and use the host as a PFCP tunnel endpoint are exposed, making impact deployment-specific. Leadership should prioritize patching affected systems because the vendor classifies the fix as this-week priority, despite no public exploit code being identified at this time.
Apply vendor patch.
Threat Intelligence Overview
NVD
CVE.org
EPSS
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Exploit-DB