/

CVE-2026-44321

Severity:

HIGH RISK

(7.5)

Missing Authentication and Improper Error Handling

CVE-2026-44321

Analyzed

Vulnerability type

Category:

Missing Authentication and Improper Error Handling

CWE:

CWE-306, CWE-617, CWE-862

Impact:

Unauthenticated Denial of Service

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

free5GC's SMF exposes the UPI management route group without OAuth2 protection, allowing unauthenticated clients to send crafted JSON to the POST /upi/v1/upNodesLinks endpoint.

Because the handler passes attacker-controlled data into configuration validation that calls a fatal logging routine on certain errors, a single malicious request can terminate the entire SMF process and disrupt 5G core control-plane services.

Affected context

The vulnerability affects deployments of free5GC SMF prior to version 4.2.2 that:

  • Enable the UPI (User Plane Information) management route group
  • Do not enforce inbound OAuth2 or equivalent authentication on /upi/v1/* endpoints
  • Run SMF in a way where logger.InitLog.Fatalf or equivalent fatal log calls exit the entire process

In these conditions, malformed or conflicting UPF configuration submitted via the UPI API can cause process-wide termination instead of being handled as a recoverable validation error.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoint at POST /upi/v1/upNodesLinks on the SMF instance (or its exposed ingress/load balancer).
  • Required access: Network reachability to the SMF UPI management interface; no valid OAuth2 token or SMF credentials required where the route group is mounted without middleware.
  • Trigger point: Sending attacker-controlled JSON that defines a new UPF with parameters (such as UE IP pools) that violate validation rules, including overlap with an existing UPF's pool.
  • Why exploitation is possible: The route group is mounted without authentication or authorization enforcement (CWE-306, CWE-862), and the handler passes untrusted configuration directly into UpNodesFromConfiguration(), which on certain validation failures calls logger.InitLog.Fatalf(...). Fatal logging aborts the entire SMF process, not just the offending request handler (CWE-617).

Why this happens

The core issue is a combination of missing access control on a sensitive management API and process-terminating error handling for validation failures.

  • From an access control perspective, the UPI management route group is exposed without OAuth2 middleware, so configuration-changing operations can be invoked by any network-reachable client (CWE-306: Missing Authentication for Critical Function and CWE-862: Missing Authorization).
  • From an error-handling perspective, configuration validation within UpNodesFromConfiguration() treats certain invalid states (such as overlapping UE IP pools between UPFs) as fatal conditions and calls logger.InitLog.Fatalf(...).

In many logging frameworks, fatal log calls terminate the entire process, which converts a simple input/validation error into a full process crash (CWE-617: Reachable Assertion and similar "fail-stop" patterns).

Abstractly, the pattern is: untrusted, unauthenticated configuration input is routed directly into validation logic that uses process-terminating assertions/fatal errors instead of safe error reporting, allowing a single malformed request to bring down a core network service.

Potential impact

  • Unauthenticated attackers can crash the SMF process with a single HTTP request.
  • Interruption of 5G session management, potentially affecting new session establishment and mobility handling.
  • Disruption of user traffic steering if SMF is central to UPF selection and path management.
  • Increased operational overhead due to repeated crashes, restarts, and potential failover events.
  • Possible cascading impact on other 5G core components depending on SMF availability and redundancy model.

General mitigation guidance

Effective mitigation combines strong access control for management APIs with resilient error-handling patterns:

  • Place all UPI/UPF management endpoints behind robust authentication and authorization controls (e.g., OAuth2 middleware or equivalent), treating them as administrative interfaces rather than general APIs.
  • Isolate management planes on separate network segments or admin-only ingress paths, reducing exposure to untrusted clients.
  • Replace process-terminating logging or assertions (fatal log calls, panics, or hard exits) in configuration validation with error returns and graceful handling that only fails the current operation, not the entire service.
  • Validate and sanitize configuration input using defensive parsing patterns, and treat conflicts like overlapping IP pools as normal validation errors that return clear responses to the caller.
  • Deploy SMF with least privileges, redundancy, and health-aware orchestration so that, even under unexpected failures, service availability is maintained by other instances.

These patterns generalize well to other control-plane and management APIs, ensuring that misconfigurations or malformed input do not result in catastrophic failure modes.

How teams detect issues like this

Detection strategies can focus on both code-level issues and runtime behavior:

  • Static analysis and linting: Flag handlers for management routes that:
  • Lack explicit authentication/authorization guards (e.g., missing middleware, annotations, or role checks).
  • Invoke fatal logging, panics, or direct process exit calls inside validation or request-handling logic.
  • Code review signals: During review, treat:
  • Any configuration-changing endpoint that is accessible without clear access control as a high-risk pattern.
  • Any usage of fatal logging or assertions in reachable runtime paths as a potential denial-of-service risk.
  • Runtime monitoring: Use metrics and logs to monitor:
  • SMF process exits with non-zero status codes and associated fatal log messages.
  • Repeated crashes that correlate with specific API traffic to /upi/v1/upNodesLinks or similar endpoints.
  • Security testing: Incorporate negative testing/fuzzing for management APIs that deliberately submit invalid or conflicting configurations, verifying that the service responds with controlled error responses rather than terminating.

Automated SAST/DAST tools and CI-integrated policy checks can help detect these patterns early in the development lifecycle.

Sources

SourceLink
github.comgithub.com/free5gc/free5gc/issues/906
github.comgithub.com/free5gc/free5gc/security/advisories/GHSA-44qj-cghf-9p97
github.comgithub.com/free5gc/smf/commit/e0974e07ddab44a67d36a563cca383b2449e33e5
github.comgithub.com/free5gc/smf/pull/203

Frequently asked

questions

Yes, if the SMF's UPI management interface is exposed (directly or via an ingress/load balancer) and the route group is mounted without authentication middleware, a remote attacker with network access can exploit it.

No, the vulnerability specifically involves missing OAuth2 (or equivalent) middleware on the UPI management route group, so the critical POST /upi/v1/upNodesLinks operation can be reached without authentication in affected configurations.

Apply strong authentication and authorization to all configuration and management endpoints, and refactor validation logic to use non-fatal error returns instead of process-terminating logging or assertions. The service should gracefully reject bad configurations rather than exiting.

Establish design-time rules that:

  • All management and configuration APIs must be treated as privileged and require authentication/authorization by default.
  • Fatal logs, asserts, and panics are forbidden in request-handling paths and user-facing validation logic.
  • Security reviews explicitly map each route to its protection controls and failure modes.

Codifying these rules into secure coding guidelines, automated checks, and CI pipelines helps prevent recurrence of similar denial-of-service vulnerabilities.

Find out what's already
exploitable in your codebase.