Jul 31, 2026·5 min read·13 visits
A null-byte input validation bug in free5GC AUSF crashes the authentication flow, causing Denial of Service for connecting subscribers.
Improper input validation of the supiOrSuci field in free5GC Authentication Server Function (AUSF) allows unauthenticated remote attackers to trigger an unhandled parsing exception, resulting in a Denial of Service (DoS) and internal stack trace exposure.
The Authentication Server Function (AUSF) of free5GC, an open-source 5G core network implementation, is vulnerable to improper input validation in its Service Based Interface (SBI) endpoint. Prior to version 1.4.5 of the AUSF component, the service accepts user-supplied string fields without verification or sanitization.
This lack of validation exposes a critical attack surface on the HTTP/2 API endpoint /nausf-auth/v1/ue-authentications. An unauthenticated remote attacker can supply malformed requests targeting the subscription identifiers, which propagates downstream to internal network functions.
The vulnerability manifests when the AUSF processes the supiOrSuci key in the request payload. By sending control characters inside this field, the attacker forces an unhandled exception inside the Go standard library, culminating in service unavailability.
The root cause of this vulnerability lies in the improper handling of string variables inside the UeAuthPostRequestProcedure function in internal/sbi/processor/ue_authentication.go. The Go programming language standard library encoding/json decodes incoming JSON payloads without rejecting or escaping embedded control characters, including null bytes (\x00).
When a client submits an authentication request containing raw null bytes in the supiOrSuci parameter, the JSON unmarshaler deserializes the malformed string. The AUSF then uses this parameter to construct an outbound HTTP request aimed at the Unified Data Management (UDM) network function.
The dynamic URL string generation process appends the unvalidated supiOrSuci value directly into the URL path segment. When the constructed URL is passed to Go's net/url.Parse() function for validation prior to execution, the parsing routine detects RFC 3986 compliance violations.
Because the URL contains control characters, the Parse() function returns a syntax error. The AUSF fails to handle this specific error condition gracefully, resulting in an unhandled exception that propagates back as an HTTP 500 Internal Server Error and leaks stack trace data.
An inspection of the vulnerable codebase in internal/sbi/processor/ue_authentication.go reveals that the supiOrSuci variable was retrieved and directly formatted into the UDM destination URL string.
// Vulnerable Code Path
func (p *Processor) UeAuthPostRequestProcedure(c *gin.Context, updateAuthenticationInfo models.UpdateAuthenticationInfo) {
...
supiOrSuci := updateAuthenticationInfo.SupiOrSuci
// The value of supiOrSuci is immediately utilized without any format checks
snName := updateAuthenticationInfo.ServingNetworkName
...
udmURL := fmt.Sprintf("http://%s/nudm-ueau/v1/%s/security-information/...", udmAddr, supiOrSuci)
// Go's net/url.Parse evaluates udmURL here, resulting in an unhandled parsing error
}The patch introduced in commit bfc4a10094dbacbd862baa4686829f3fcc06ce1e inserts two validator functions to sanitize the incoming identifier.
// Patched Code Path
func (p *Processor) UeAuthPostRequestProcedure(c *gin.Context, updateAuthenticationInfo models.UpdateAuthenticationInfo) {
...
supiOrSuci := updateAuthenticationInfo.SupiOrSuci
// Added validation block to catch malformed inputs
if !validator.IsValidSupi(supiOrSuci) && !validator.IsValidSuci(supiOrSuci) {
logger.UeAuthLog.Warnf("invalid supiOrSuci in UE authentication request: %q", supiOrSuci)
problemDetails := models.ProblemDetails{
Title: "Malformed request syntax",
Status: http.StatusBadRequest,
Detail: "supiOrSuci must be a valid SUPI or SUCI",
Cause: "MALFORMED_SUPI_OR_SUCI",
}
c.Set(sbi.IN_PB_DETAILS_CTX_STR, problemDetails.Cause)
c.JSON(http.StatusBadRequest, problemDetails)
return
}
snName := updateAuthenticationInfo.ServingNetworkName
...
}This validator check ensures that the input conforms strictly to the structural rules of Subscriber Permanent Identifiers (SUPI) and Subscription Concealed Identifiers (SUCI). Any input containing non-conforming characters or control bytes is safely rejected before reaching the URL parser.
Exploitation of CVE-2026-53551 does not require prior authentication or specialized network permissions. The attacker needs only network-level access to the Service Based Interface (SBI) endpoint of the AUSF, typically hosted on TCP port 8000.
The attack vector involves sending a single HTTP POST request to /nausf-auth/v1/ue-authentications with a JSON payload where the supiOrSuci field contains null bytes. The structure of the exploit request is illustrated in the following sequence:
By repeatedly issuing this malformed request, an attacker can consume processing threads and memory resources as the service struggles with consecutive unhandled exceptions. This sequence effectively triggers a Denial of Service for all valid core network subscribers attempting to authenticate.
The impact of this vulnerability is categorized as a partial Denial of Service on a core network component. Since the AUSF is responsible for processing all user authentication requests, a disruption in this component prevents any new User Equipment (UE) from connecting to the 5G core.
In addition to service disruption, the vulnerability causes information disclosure. The Go runtime logs and returning payloads leak detailed system stack traces and error metadata that can aid attackers in mapping the internal network topology and component versions.
The CVSS v4.0 rating is calculated as 6.9, with a focus on low availability impact on the network service itself. Because free5GC is commonly used in private 5G deployments, enterprise networks, and testbed environments, the threat surface is localized to networks exposing the SBI endpoints.
The primary remediation path is upgrading the affected software components to versions containing the validation patch. Operators must transition to free5GC version 4.2.2 or higher, which includes AUSF version 1.4.5.
For environments where immediate system upgrades are not possible, operators should deploy an API Gateway or Web Application Firewall (WAF) in front of the AUSF SBI interface. The gateway must be configured to inspect HTTP/2 POST requests targeting /nausf-auth/v1/ue-authentications and discard payloads containing control characters.
Additionally, network segregation should be enforced. The Service Based Interface must be restricted to internal network segments (the 5G Core control plane) and isolated from the public internet or untrusted user-plane segments.
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
ausf free5gc | < 1.4.5 | 1.4.5 |
free5gc free5gc | < 4.2.2 | 4.2.2 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-20 |
| Attack Vector | Network (Unauthenticated) |
| CVSS v4.0 | 6.9 (Medium) |
| Impact | Denial of Service (DoS) |
| Exploit Status | PoC available |
| CISA KEV Status | Not Listed |
The product receives input or data, but does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.
CVE-2026-55622 (GHSA-qx75-2p3r-pwm5) is an improper access control vulnerability (CWE-284) in Canonical LXD and LXC Incus (tracked as GHSA-c9f5-j9c3-mhrg). In multi-tenant deployments utilizing project-based isolation, the REST API handler for instance creation via POST /1.0/instances verifies that the authenticated user has authorization in the destination project specified by the query parameter, but fails to verify whether the user holds read or view permissions for the source instance when executing a copy operation across projects. Consequently, an authenticated client restricted to a single project can clone instances or snapshots from unauthorized projects into their own project, resulting in complete disclosure of the target instance filesystem and embedded credentials.
An authorization bypass vulnerability in Canonical LXD (tracked as GHSA-7mr3-28h5-m5vx and CVE-2026-55621, and as GHSA-64f3-v33m-w89f in Linux Containers Incus) allows an authenticated user with restricted project access to copy custom storage volumes and volume snapshots from unauthorized projects. The flaw resides in the storagePoolVolumesPost REST API handler, which verifies permissions on the destination project but fails to check whether the caller holds view entitlements on the source project or volume specified in the request body.
A missing authorization and configuration validation vulnerability in Canonical LXD and LXC Incus allows authenticated users within restricted projects to bypass project security boundaries. By smuggling prohibited low-level configuration directives (such as raw.lxc or raw.qemu) inside instance snapshots or backup archives, an attacker can restore these configurations within a restricted project and execute arbitrary commands with root privileges on the underlying host operating system.
A symbolic link traversal vulnerability (CWE-59) in Canonical LXD and Linux Containers Incus allows an authenticated user with image import permissions to read and write arbitrary files on the host filesystem. During image archive unpacking, the daemon fails to reject top-level symbolic links for the instance `templates` directory. Subsequent requests to the instance template API endpoints follow this symbolic link outside the instance storage directory with root privileges, enabling complete host compromise.
CVE-2026-12411 is a broken access control vulnerability in the DevLXD interface of Canonical LXD versions 6.6 through 6.8. The flaw resides in the devLXDInstancePatchHandler component, which fails to verify storage volume ownership when an instance attaches a new disk device via the /dev/lxd guest socket. When the security.devlxd.management.volumes configuration option is enabled, an untrusted guest or DevLXD identity can issue a crafted HTTP PATCH request referencing another tenant's custom storage volume. The LXD host daemon subsequently mounts the target volume into the requesting guest, permitting unauthorized cross-tenant read and write operations.
CVE-2026-105769 (GHSA-5q7h-w9jf-cx97, GO-2026-6225) is an origin validation error and credential exfiltration vulnerability affecting Kaniko prior to version 1.25.20. The flaw stems from an unanchored regular expression in the integrated Azure Container Registry (ACR) credential helper (github.com/chrismellard/docker-credential-acr-env). When Kaniko processes a Dockerfile containing an image reference hosted on a lookalike domain containing an ACR suffix as a substring (e.g., x.azurecr.io.attacker.com), the credential helper acquires a Microsoft Entra ID access token for Azure Resource Manager and transmits it via HTTP POST to the attacker-controlled host.