/

CVE-2026-44328

Severity:

HIGH RISK

(8.2)

Denial of Service via Improper Authentication and Null

CVE-2026-44328

Analyzed

Vulnerability type

Category:

Denial of Service via Improper Authentication and Null Pointer Dereference

CWE:

CWE-306, CWE-476, CWE-862

Impact:

Unauthenticated Denial of Service with Unintended State Mutation

Severity:

HIGH RISK

(8.2)

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 Session Management Function (SMF) exposes the UPI management DELETE endpoint without authentication and mishandles AN-typed nodes that lack an associated UPF object. An unauthenticated attacker can issue a crafted DELETE request that both mutates the in-memory user-plane topology and triggers a nil-pointer panic, causing a denial of service.

Because this occurs over an unauthenticated network API path, an off-path network attacker who can reach the SMF can repeatedly crash the service and disrupt 5G core control-plane stability.

Affected context

The vulnerability affects free5GC deployments where:

  • The SMF exposes the UPI management route group
  • The UPI management routes are mounted without inbound OAuth2 or equivalent authentication middleware
  • Access to the SMF's management API network surface is possible from untrusted or partially trusted networks
  • AN-typed nodes (e.g., gNB entries) exist in the in-memory user-plane topology without attached UPF objects

In this context, DELETE operations on AN entries can both alter the in-memory topology and crash the handler due to nil-pointer dereferences.

Exploit preconditions

  • Attack surface: HTTP-based UPI management API on the SMF (e.g., /upi/v1/upNodesLinks/{upNodeRef})
  • Required access: Network-level ability to send HTTP requests to the SMF's management interface; no authentication required on the vulnerable route group
  • Trigger point: An HTTP DELETE request targeting an AN-type upNodeRef such as a gNB identifier (e.g., DELETE /upi/v1/upNodesLinks/gNB1)
  • Why exploitation is possible:
  • The UPI management route group is mounted without OAuth2 or equivalent authentication/authorization (CWE-306, CWE-862)
  • The handler unconditionally dereferences upNode.UPF after an async release, despite AN-typed nodes being created without a UPF object (CWE-476)
  • The state-mutating deletion call (UpNodeDelete(upNodeRef)) executes prior to the nil-pointer panic, ensuring topology changes even on failed requests

Why this happens

The underlying bug is a combination of missing access control and unsafe pointer handling in a network-facing control-plane handler.

First, the UPI management route group is exposed without OAuth2 middleware or equivalent checks, violating CWE-306: Missing Authentication for Critical Function and CWE-862: Missing Authorization. This allows untrusted callers to invoke state-changing operations on critical user-plane topology resources.

Second, the DELETE /upi/v1/upNodesLinks/{upNodeRef} handler assumes that all nodes have an associated UPF object and unconditionally dereferences upNode.UPF after an asynchronous, type-guarded release path. AN-typed nodes, however, are created without a UPF object, so dereferencing upNode.UPF results in a nil-pointer panic consistent with CWE-476: NULL Pointer Dereference.

The logic further compounds impact by performing UpNodeDelete(upNodeRef) before the dereference. This ordering means state mutation is committed to the in-memory topology even though the handler crashes, leaving the system in a partially updated state and enabling repeated crash cycles through unauthenticated calls.

Potential impact

  • Unauthenticated attackers can crash the SMF process via repeated malicious DELETE requests
  • Disruption of control-plane functions dependent on SMF availability, potentially impacting session management and user-plane routing
  • In-memory user-plane topology may be altered (e.g., AN entries removed) before each crash, resulting in inconsistent or unexpected routing state
  • Increased operational overhead due to repeated restarts, failover events, and recovery procedures
  • Potential cascading reliability issues in multi-component 5G core deployments that depend on SMF stability

General mitigation guidance

Effective mitigation focuses on enforcing strict access control on management APIs and hardening handler logic against unsafe dereferences.

Recommended defensive patterns include:

  • Enforce authentication on all management routes: Apply OAuth2 or equivalent middleware consistently across the UPI management route group so state-changing operations require authenticated and authorized callers.
  • Apply fine-grained authorization checks: Beyond authentication, ensure only privileged roles can modify user-plane topology (e.g., delete upNodesLinks), aligning with least-privilege principles.
  • Harden pointer and reference handling: Introduce explicit nil checks and type validation before dereferencing objects such as upNode.UPF, and handle missing objects with controlled error responses rather than panics.
  • Separate state mutation from risky operations: Structure handlers so that all validation (including type and presence checks) is completed before making irreversible state changes to the in-memory topology or configuration.
  • Defensive defaults for management interfaces: Prefer restrictive network exposure for control-plane and management APIs, such as binding to dedicated management networks, using mTLS, and applying network-layer filtering to reduce attack surface.

How teams detect issues like this

Detection strategies can combine code-level analysis with runtime observability:

  • Static analysis and code review:
  • Flag route groups or controllers that lack authentication/authorization middleware but expose CREATE/UPDATE/DELETE semantics.
  • Search for handlers that perform state mutations prior to comprehensive error and type checks.
  • Identify code paths where pointers or object references (such as UPF fields) are dereferenced without prior nil checks, especially in network handlers.
  • Automated policy enforcement:
  • Use API gateway or ingress policies requiring authentication for all management paths by default.
  • Enforce CI/CD checks that reject additions to management APIs unless explicit authentication/authorization is present.
  • Runtime monitoring and logging:
  • Monitor SMF logs for patterns of handler panics or nil-pointer exceptions associated with DELETE operations on upNodesLinks.
  • Set alerts for repeated crashes or restarts of SMF pods or processes, correlating with suspicious access to /upi/v1/ endpoints.
  • Security testing:
  • Incorporate negative testing and fuzzing of management endpoints to uncover unauthenticated state changes and crash conditions.

Sources

SourceLink
github.comgithub.com/free5gc/free5gc/issues/905
github.comgithub.com/free5gc/free5gc/security/advisories/GHSA-p9mg-74mg-cwwr
github.comgithub.com/free5gc/smf/commit/b57bc48081c3d3a2f333d02eb78e4fd31a120deb
github.comgithub.com/free5gc/smf/pull/199

Frequently asked

questions

Yes. As long as an attacker can reach the SMF's UPI management API over the network, they can send crafted DELETE requests to trigger the nil-pointer panic and state mutation without prior authentication.

No credentials are required on the vulnerable route group. However, the attacker must have network-layer access to the SMF's management interface; deployments that fully isolate this interface from untrusted networks reduce practical exposure.

The most robust fix is to require strong authentication and authorization for all state-changing management operations and to ensure any handler validates object presence and type before dereferencing or mutating state. In practice, this means consistently applying auth middleware to UPI management routes and restructuring the handler to check for missing UPF objects and fail gracefully.

Adopt secure-by-default patterns for management APIs: mandate authentication and authorization for all non-read operations, enforce least-privilege roles, use static analysis to detect unauthenticated critical functions and unchecked dereferences, and include chaos and fault-injection tests that verify the system responds with controlled errors rather than panics when encountering unexpected input or topology states.

Find out what's already
exploitable in your codebase.