CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-55785

CVE-2026-55785: Non-Constant-Time Cryptographic Comparison and Sensitive Information Leakage in free5GC AUSF

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 29, 2026·5 min read·25 visits

Executive Summary (TL;DR)

The free5GC AUSF component prior to version 1.4.5 leaks expected authentication secrets in plaintext console logs and verifies user authentication responses using non-constant-time operations, allowing potential credential recovery.

free5GC is an open-source implementation of the 5G core network. Prior to version 1.4.5, the Authentication Server Function (AUSF) component of free5GC performs cryptographic comparisons within its Service-Based Interface (SBI) handling logic using non-constant-time helpers. These comparison utilities return immediately upon encountering a mismatching character, creating a covert timing channel. Concurrently, the AUSF writes the expected validation vector to standard output logs at the INFO level, exposing sensitive cryptographic material to unauthorized processes or logging agents.

Vulnerability Overview

The free5GC Authentication Server Function (AUSF) acts as the authority verifying that a connecting User Equipment (UE) has computed a valid response vector corresponding to the home network's expectations. These protocol sequences operate under either 5G-AKA or EAP-AKA' profiles, as defined by 3GPP standards. The vulnerability resides inside the processor package of the SBI handling layer, specifically in the file internal/sbi/processor/ue_authentication.go.

By leveraging standard, non-constant-time comparison primitives, the AUSF introduces side-channel vulnerabilities during the verification of the cryptographic parameters RES*, XRES*, AT_MAC, and XMAC. Furthermore, the code prints the plaintext expected validation strings into standard system output at the INFO logging level.

This flaw exposes the 5G core's subscriber credential management mechanisms. This combination of structural flaws introduces two separate risk vectors: a timing-discrepancy vector under specific noise-free topologies, and a high-exposure diagnostic logging vector across all cloud environments.

Root Cause Analysis

The application's structural weakness stems from two independent coding errors in the validation of network challenge responses. Under 3GPP specifications, the AUSF generates expected authorization response challenges (XRES* or XRES) and expects the client to present a corresponding RES* or RES parameter calculated from its subscriber identity module.

First, during 5G-AKA validation, the AUSF invokes Go's native strings.EqualFold string equality wrapper to compare user responses against the internal expected vector. The execution flow of strings.EqualFold processes strings byte-by-byte and returns immediately upon discovering a mismatch. Because of this short-circuit logic, the total execution elapsed duration varies predictably depending on how many leading bytes of the client's guess match the correct token.

Second, the validation path for EAP-AKA' relies on standard bytes.Equal logic and the normal comparison operator == to validate cryptographic hash blocks. This implementation behaves exactly like the string comparison functions, introducing a covert timing channel. Compounding this risk, the developer included verbose logging statements that export the master confirmation vector (XresStar) to standard logs. This output is evaluated prior to validation, exposing credential strings to container orchestrators, sidecars, or syslog listeners.

Code Analysis and Differential Patch Walkthrough

The patch implemented in free5GC commit 7a5a4aa1ec6cd0e1febebf333911c3104968edf0 introduces constant-time evaluation and removes diagnostic leaks. In the vulnerable code, the Auth5gAkaComfirmRequestProcedure processes verification as follows:

// VULNERABLE CODE (Pre-v1.4.5)
logger.Auth5gAkaLog.Infof("res*: %x\nXres*: %x\n", updateConfirmationData.ResStar, ausfCurrentContext.XresStar)
if strings.EqualFold(updateConfirmationData.ResStar, ausfCurrentContext.XresStar) {
    // Authentication success
}

The fix addresses this by replacing the non-constant comparisons with secure comparison algorithms and deleting the logger instructions:

// PATCHED CODE (v1.4.5)
if constantTimeHexEqual(updateConfirmationData.ResStar, ausfCurrentContext.XresStar) {
    // Authentication success
}

The patch defines two custom validation wrappers to enforce uniform execution paths across different variable types:

func constantTimeHexEqual(a, b string) bool {
	aBytes, err := hex.DecodeString(a)
	if err != nil {
		return false
	}
	bBytes, err := hex.DecodeString(b)
	if err != nil {
		return false
	}
	return constantTimeEqual(aBytes, bBytes)
}
 
func constantTimeEqual(a, b []byte) bool {
	return len(a) == len(b) && subtle.ConstantTimeCompare(a, b) == 1
}

By calling subtle.ConstantTimeCompare, the process executes a bitwise comparison across the entire length of both byte arrays, eliminating any variation in timing. While the conditional length check (len(a) == len(b)) technically short-circuits, 5G authentication parameters are fixed in size, rendering the resulting timing variance useless to adversaries.

Exploitation and Attack Path Scenario

The vulnerability presents two practical attack paths based on configuration and target environment constraints. These are split between a static local timing evaluation and a direct credential harvest via diagnostic systems.

Attack Path 1: Log-Harvesting Exploitation

An attacker targeting the cloud-native infrastructure exploits the logging weakness directly. If the attacker has compromised a co-resident pod, a telemetry collection system, or a local log aggregator, they query the stream for XresStar. Armed with the correct vector, they submit authentication confirmation requests using the stolen value, authenticating successfully as the targeted subscriber without performing any mathematical or cryptographic calculations.

Attack Path 2: Local Timing Analysis

An attacker attempts a side-channel attack targeting co-resident container systems where virtualization limits network jitter. The adversary initiates repetitive authentication procedures while tracking system processing latency at nanosecond-scale precision. By performing a character-by-character brute force, the adversary identifies longer processing windows indicating a correct prefix match. This allows complete recovery of validation keys over several million requests.

Impact Assessment

The impact of CVE-2026-55785 is concentrated on the confidentiality of 5G subscriber sessions. While rated as CVSS 3.7 (Low) due to the high complexity required to exploit timing vectors over live internet routing infrastructure, the practical severity increases to High in shared-tenant cloud platforms.

If the plaintext logger statements are active, any operator or adjacent software system capable of reading log containers or standard output streams can obtain active authentication challenges. This completely compromises authentication token confidentiality, allowing rogue hardware or emulation scripts to spoof subscriber identities. This compromises the non-repudiation guarantees of the 5G Service-Based Architecture.

Official Patches

free5gcFix commit for AUSF timing side-channel and logging vulnerabilities

Fix Analysis (1)

Technical Appendix

CVSS Score
3.7/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N

Affected Systems

free5gc AUSF

Affected Versions Detail

Product
Affected Versions
Fixed Version
ausf
free5gc
< 1.4.51.4.5
AttributeDetail
CWE IdentifierCWE-208: Observable Timing Discrepancy
Secondary CWECWE-532: Insertion of Sensitive Information into Log File
Attack VectorNetwork
CVSS v3.1 Score3.7
Exploit Statusnone
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1552.001Credentials In Files
Credential Access
CWE-208
Observable Timing Discrepancy

The use of non-constant-time string and byte comparison logic allows adversaries to extract keys or internal data via timing analysis, while verbose logger scripts write keys into diagnostic system outputs.

Vulnerability Timeline

Security patch authored and committed to branch.
2026-06-19
GitHub Advisory GHSA-fp46-6vfw-gc9c published.
2026-08-28
CVE-2026-55785 published.
2026-08-28

References & Sources

  • [1]GitHub Security Advisory GHSA-fp46-6vfw-gc9c
  • [2]free5gc/ausf Patch Commit
  • [3]free5gc/ausf Pull Request 63
  • [4]free5gc/ausf Tag Release v1.4.5

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•35 minutes ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-126304
8.7

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
6 views•9 min read
•about 5 hours ago•CVE-2026-128077
6.5

CVE-2026-128077: Authorization Bypass via Request Path Desynchronization in Nuxt and @nuxt/nitro-server

CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours ago•CVE-2026-128084
4.8

CVE-2026-128084: Integer Truncation and SQL Query Truncation in sqlite3-ruby

Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.

Alon Barad
Alon Barad
5 views•11 min read