84 Vulnerabilities Identified in 4G and 5G Core Networks, Including a Session Hijacking Flaw

Key Takeaways

• Researchers identified a pervasive class of security flaws—called implicit trust errors (iTrue)—in 4G/5G core networks arising from blind trust between network functions.
• The iTrue vulnerabilities affect both LTE and 5G implementations, spanning the GTP‑C and PFCP signaling protocols, and can enable denial‑of‑service (DoS) attacks or session hijacking.
• A novel multi‑agent framework powered by a large language model (LLM), dubbed iFinder, was used to summarize known flaws, generate detection patterns, and discover 84 previously unknown vulnerabilities, 83 of which were confirmed and 81 assigned CVE IDs.
• Many 5G iTrue flaws were inherited from their 4G counterparts, showing that security deficiencies can persist across generations when legacy trust models are not re‑examined for cloud‑native deployments.
• Successful exploitation requires the attacker to reach internal core‑network interfaces (e.g., via IP discovery, misconfigured cloud boundaries, or a compromised UE) and to inject crafted PFCP/GTP‑C messages.
• Proof‑of‑concept attacks demonstrated session hijacking by abusing duplicate Packet Detection Rule (PDR) IDs in PFCP Session Modification Requests and DoS by crashing the Serving Gateway Control plane via malformed GTPv2‑C messages.
• Two real‑world commercial 5G core networks confirmed the session‑hijacking flaw; one vendor has patched it (CVE‑2026‑8233, CVSS 4.6), while another major carrier is still remediating.
• The findings underscore an urgent need for vendors and operators to re‑evaluate trust assumptions, enforce strict message validation, and adopt continuous security testing in cloud‑native core networks.

Overview of the Study
A team from Nanyang Technological University published a paper titled “Understanding Implicit Trust Errors in Core Carrier Networks through Multi‑Agent Flaw Discovery and Analysis.” The research examined the security of LTE (4G) and 5G core networks by focusing on two critical signaling interfaces: GTP‑C (GPRS Tunnelling Protocol Control Plane) and PFCP (Packet Forwarding Control Protocol). The study analyzed seven open‑source core‑network implementations—Open5GS and OpenAirInterface for LTE, and Open5GS, free5GC, OpenAirInterface, SD‑Core, and eUPF for 5G—to uncover systemic weaknesses that could be leveraged for disruptive attacks.

Root Cause: Implicit Trust Errors
The researchers identified a single recurring root cause: implicit trust between core‑network functions. Traditionally, cellular core networks relied on physical isolation to keep interfaces within a trusted zone. However, the shift to cloud‑native, containerized deployments has eroded this isolation, making the trust model fragile and expanding the attack surface. When network components blindly accept messages from presumed internal peers without validating format, semantics, or resource availability, attackers who can reach those interfaces can exploit the resulting implicit trust errors (iTrue) to launch denial‑of‑service or session‑hijacking campaigns.

Methodology: iFinder Framework
To detect and understand iTrues, the team built a large language model‑assisted multi‑agent system called iFinder. The framework operates in several stages: first, it summarizes known vulnerabilities and extracts detection patterns; second, it uses those patterns as a basis to search for new iTrue candidates in the target codebases; third, it applies a novel code‑specification cross‑checking technique to weed out hallucinations and false positives; finally, an LLM‑driven component generates proof‑of‑concept (PoC) exploits, which are iteratively refined by executing them against the core‑network implementations and analyzing the outcomes. This automated pipeline enabled the researchers to scale vulnerability discovery across multiple implementations efficiently.

Detection and Validation Process
False‑positive elimination hinges on mapping each iTrue candidate to the specific protocol procedure it purportedly affects and verifying whether the corresponding validation and resource checks are actually enforced in the source code. If the required checks are missing or insufficient, the candidate is retained as a genuine vulnerability. This rigorous cross‑validation ensures that the reported flaws reflect real gaps in the implementations rather than artefacts of the LLM’s generative process.

Discovered Vulnerabilities
Running iFinder against the seven open‑source core‑network versions yielded 84 previously unknown vulnerabilities. Of these, 83 were confirmed by the developers, and 81 received CVE identifiers, underscoring the scale and validity of the findings. The vulnerabilities span both LTE and 5G stacks, affecting functions such as the Serving Gateway Control plane (SGW‑C), the User Plane Function (UPF), and the Session Management Function (SMF). The high confirmation rate indicates that the implicit trust problem is not a handful of isolated bugs but a systemic issue permeating multiple implementations.

Inheritance Across Generations
Many of the iTrue flaws identified in 5G cores were traced back to their 4G predecessors. This inheritance demonstrates that security deficiencies can persist when legacy code is reused or adapted without a thorough reassessment of trust assumptions in the new cloud‑native context. As operators upgrade from LTE to 5G, they may inadvertently carry forward vulnerabilities that were previously mitigated by physical isolation, now exposed in a more open, software‑defined environment.

Attack Vectors and Assumptions
Exploiting the discovered iTrue flaws presupposes that an attacker can reach the internal core‑network interfaces. This can be achieved through: (1) obtaining the IP address of core components via public documentation, passive network enumeration, or active scanning; (2) exploiting misconfigurations in cloud deployments that inadvertently expose internal services to the internet; or (3) compromising a User Equipment (UE) device and using it as a pivot to inject malicious payloads into the uplink data stream. Once the attacker gains the ability to send arbitrary PFCP or GTP‑C messages, they can violate the trust model and trigger the vulnerabilities.

Example Attack: Session Hijacking via Duplicate PDR IDs
One illustrative iTrue involves the PFCP Session Modification Request message. The attack proceeds as follows:

1. The attacker sends a PFCP Association Setup Request to the UPF.
2. The victim UE initiates an attach, prompting the SMF to issue a PFCP Session Establishment Request to the UPF.
3. The attacker then crafts a PFCP Session Modification Request that reuses the victim’s Packet Detection Rule (PDR) ID but assigns it a lower Precedence value (higher priority) and binds it to a malicious Forwarding Action Rule (FAR).
4. Because the UPF lacks validation for PDR ID uniqueness, it accepts the duplicate PDR, sorts PDRs by precedence, and places the malicious rule ahead of the legitimate one.
5. During packet processing, the UPF matches the malicious PDR first, establishing a forwarding tunnel between the UPF and the attacker.
6. Consequently, the victim’s uplink traffic is diverted to the attacker instead of being routed to the internet.

This session‑hijacking flaw has been observed in two live commercial 5G core networks. One vendor, Dotouch, has patched the issue (CVE‑2026‑8233, CVSS 4.6), while another major 5G carrier is still in the remediation process.

Denial‑of‑Service Example
A separate iTrue can trigger a DoS condition in the SGW‑C of Open5GS LTE. By sending specially crafted GTPv2‑C Create Session Request messages, an attacker can cause the SGW‑C to crash during message parsing, thereby disrupting service for all users relying on that gateway. The vulnerability stems from missing length or format checks on GTP‑C messages, allowing malformed inputs to destabilize the control plane.

Real‑World Impact and Vendor Response
The disclosure of 81 CVEs highlights the practical risk posed by implicit trust errors. Vendors have begun issuing patches, but the persistence of similar flaws across multiple implementations suggests that piecemeal fixes may not be sufficient. The researchers urge a holistic reassessment of trust boundaries, enforcement of strict message validation (format, semantics, and resource checks), and adoption of continuous security testing—such as fuzzing and model‑based verification—throughout the development lifecycle of cloud‑native core networks.

Implications and Recommendations
The study reveals that the migration to cloud‑native architectures has exposed a latent trust‑based vulnerability class that spans generations of mobile technology. To mitigate these risks, network operators and equipment manufacturers should:

• Implement zero‑trust principles at the software layer, authenticating and authorizing every inter‑function message regardless of presumed origin.
• Enforce rigorous schema‑based validation for GTP‑C and PFCP messages, including checks for field uniqueness, length, and semantic consistency.
• Deploy runtime monitoring and anomaly detection to spot unusual message patterns that may indicate exploitation attempts.
• Conduct regular security assessments, including automated multi‑agent flaw discovery akin to iFinder, especially after major updates or when integrating new open‑source components.
• Share vulnerability information promptly across the industry to prevent the re‑emergence of inherited flaws in future releases.

By addressing the underlying implicit trust assumptions rather than merely patching individual bugs, the mobile ecosystem can harden its core networks against both current and emerging threats.