Summary
free5GC go-upf up to and including 1.2.6, in conjunction with free5GC SMF up to and including 1.4.0, contains an improper input validation and protocol compliance flaw in processing PFCP Association Setup Requests.
A remote attacker can send a malformed PFCP Association Setup Request that is incorrectly accepted, pushing the UPF into an inconsistent state and causing SMF reconnection loops and denial of service for core network functions.
Affected context
This vulnerability exists in free5GC deployments that:
- Use the go-upf component (versions up to and including 1.2.6)
- Use the corresponding SMF component (versions up to and including 1.4.0)
- Exchange PFCP control-plane messages between SMF and UPF
- Rely on PFCP Association Setup Requests for establishing UPF-SMF control sessions
The issue is triggered during PFCP Association setup when malformed or non-compliant PFCP messages are not rejected and instead are treated as valid, leaving the UPF in a logically inconsistent protocol state.
Exploit preconditions
- Attack surface: PFCP control-plane interface exposed between SMF and UPF (typically internal to the 5G core control network, but reachable by any entity able to send PFCP to the UPF).
- Required access: Network-level ability to send PFCP Association Setup Requests to the UPF's PFCP endpoint; no valid PFCP association is required beforehand.
- Trigger point: Receipt and processing of a specially crafted, malformed PFCP Association Setup Request during association establishment.
- Why exploitation is possible: The UPF's PFCP association handling logic does not fully validate protocol fields or enforce stricter PFCP compliance, allowing invalid messages to be treated as successful association setups. This results in inconsistent internal state that is later exercised by legitimate SMF traffic, causing reconnection loops and service degradation.
Why this happens
The root cause lies in improper input validation and incomplete protocol state validation within the PFCP Association handling code path.
Instead of strictly validating PFCP Association Setup Requests against the PFCP specification (e.g., checking mandatory information elements, value ranges, message structure, and state preconditions), the UPF accepts malformed or protocol-inconsistent messages as valid.
This is an instance of CWE-20: Improper Input Validation, where externally supplied protocol data is not rigorously checked before being used to update internal state. The result is that the UPF enters a state that is not representable in the PFCP specification, causing downstream control-plane behavior (such as SMF reconnection logic) to malfunction and leading to denial of service.
Potential impact
- Disruption of PFCP control-plane connectivity between SMF and UPF
- SMF reconnection loops that can consume resources and reduce control-plane availability
- Degradation or loss of user-plane data forwarding for affected sessions or slices
- Wider core network instability if multiple UPFs or SMFs are affected in a shared deployment
- Potential cascading service impact on subscribers relying on the affected 5G core instance
General mitigation guidance
While a specific product fix is outside the scope of this discussion, general mitigation strategies for this class of issue include:
- Stricter protocol validation: Implement defensive parsing of PFCP messages, validating all mandatory fields, data types, lengths, and value ranges, and rejecting messages that deviate from the PFCP specification.
- State machine hardening: Explicitly model PFCP association state transitions and enforce that only valid transitions are allowed; invalid or unexpected messages should fail closed without altering critical state.
- Input sanitization at trust boundaries: Treat all PFCP traffic, even from ostensibly trusted peers, as untrusted input and subject it to full syntactic and semantic validation.
- Graceful error handling: When malformed protocol messages are detected, fail the association setup cleanly, log the event, and avoid entering partially initialized or ambiguous states.
- Defense in depth at the network layer: Use network policies, firewall rules, or segmentation to ensure only intended SMF instances can send PFCP traffic to UPFs, reducing the potential attacker population.
- Resource and rate limiting: Apply per-peer or per-interface limits on PFCP association attempts to reduce the impact of repeated malformed requests and to prevent control-plane exhaustion.
How teams detect issues like this
To detect and monitor for this class of vulnerability, organizations can:
- Static analysis and code review:
- Look for protocol parsing paths that accept incoming PFCP messages and update core state without comprehensive field validation or error checks.
- Review PFCP state machine implementations to ensure all state transitions are guarded by explicit checks and that malformed messages lead to well-defined error paths.
- Flag direct use of parsed fields without length, bounds, or mandatory-field verification.
- Dynamic testing and fuzzing:
- Use protocol-aware fuzzers to send malformed or boundary-value PFCP Association Setup Requests to a test deployment and observe if the UPF enters inconsistent states or triggers control-plane reconnections.
- Incorporate PFCP compliance test suites into CI pipelines to validate correctness across versions.
- Runtime monitoring and logging:
- Monitor logs for repeated PFCP Association setup failures, unexpected association state changes, or SMF-UPF reconnection loops.
- Implement alerts for anomalous rates of PFCP Association requests from unusual sources.
- Automated security review tooling:
- Integrate automated code scanning tools configured with rules for improper input validation and protocol parsing anti-patterns.

