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-14643

CVE-2026-14643: Shared Cache Pollution and Information Disclosure via Whitespace Parsing Discrepancies in Undici

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 4, 2026·6 min read·66 visits

Executive Summary (TL;DR)

An interpretation conflict in undici's cache parser fails to strip whitespace from Cache-Control directives, leading to unauthorized sharing of private cached data.

An interpretation conflict (CWE-436) in the cache interceptor of the undici HTTP client for Node.js causes whitespace-padded Cache-Control directives to be parsed incorrectly, leading to shared cache pollution and the unauthorized disclosure of sensitive, private, or authenticated user information (CWE-524).

Vulnerability Overview

CVE-2026-14643 identifies an interpretation conflict (CWE-436) within the Cache Interceptor component of undici, the default HTTP client for Node.js. This defect specifically impacts deployments where the Cache Interceptor is configured to operate in shared-cache mode (shared: true). When parsing HTTP response headers, the engine fails to adequately normalize whitespace in specific Cache-Control directives.\n\nThe primary risk associated with this vulnerability is the unintentional caching and subsequent reuse of HTTP responses containing sensitive, authenticated information (CWE-524). An attacker can leverage this parsing discrepancy to intercept private data destined for other authenticated users. The vulnerability occurs without direct user interaction and can be executed remotely over the network, though it requires specific caching configurations to be active.\n\nThis vulnerability represents a regression or an incomplete fix from a previous security advisory, CVE-2026-9678. The earlier fix omitted validation logic for optional whitespace (OWS) located around the equality sign or inside quoted arguments of qualified no-cache and private cache directives.

Root Cause Analysis

The root cause of CVE-2026-14643 lies in lib/util/cache.js inside the parseCacheControlHeader function of the undici library. This function is responsible for interpreting directives such as private="authorization" or no-cache="authorization". According to RFC 9111, if an upstream server marks specific headers as private or no-cache, a shared cache must not store or serve those portions of the response to other clients.\n\nWhen the upstream server responds with optional whitespace around the equals sign or inside the quoted parameters, the parser's logic breaks. For example, if the upstream server returns Cache-Control: private=" authorization", the parser processes the value verbatim. Because it fails to sanitize or trim leading and trailing whitespaces, it stores the field restriction as " authorization" instead of "authorization".\n\nDuring subsequent request matching, the cache engine performs a strict equality lookup between the client's request headers and the stored restricted headers array. Because " authorization" containing whitespace does not match "authorization", the comparison evaluates to false. The cache interceptor then erroneously concludes that no private or restricted headers are present in the cached entry, allowing the cached response to be served to unauthenticated users.

Code Analysis

To understand the exact failure mechanism, we examine the difference in lib/util/cache.js before and after the applied patch. In the vulnerable version, the array of extracted headers was populated directly from the parsed token values without trimming whitespace characters.\n\nBelow is the comparison of the parser logic, highlighting how the patch normalizes the headers using JavaScript's .trim() method:\n\njavascript\n// Vulnerable logic\nif (key in output) {\n output[key] = output[key].concat(headers)\n} else {\n output[key] = headers\n}\n\n// Patched logic\nfor (let j = 0; j < headers.length; j++) {\n headers[j] = headers[j].trim()\n}\nif (key in output) {\n output[key] = output[key].concat(headers)\n} else {\n output[key] = headers\n}\n\n\nAdditionally, the patch addresses single-value scenarios, such as no-cache="some-header". Instead of pushing the raw string directly into the output array, it now binds the trimmed value to a new constant fieldName before storage:\n\njavascript\n// Patched single-value handling\nconst fieldName = value.trim()\nif (key in output) {\n output[key] = output[key].concat(fieldName)\n} else {\n output[key] = [fieldName]\n}\n\n\nThis corrective action eliminates any whitespace-padded headers from the final restricted list. It ensures that standard matching routines (such as Array.prototype.includes) perform accurately against sanitized request keys during cache evaluation.

Exploitation Methodology

To successfully exploit this vulnerability, an attacker must target an application utilizing an affected version of undici with the Cache Interceptor running in shared-cache mode. The upstream server must also return a Cache-Control header that includes whitespace-padded qualified directives. An example of such a header is Cache-Control: public, max-age=120, private=" authorization".\n\nBelow is a sequence diagram illustrating the flow of the exploitation technique:\n\nmermaid\ngraph LR\n Victim["Victim (Authenticated)"] -->|1. GET /profile with Auth Header| Proxy["Undici Shared Cache Client"]\n Proxy -->|2. Forward Request| Origin["Upstream Server (Origin)"]\n Origin -->|3. Response with private=' authorization'| Proxy\n Proxy -->|4. Parse failure: Stores cache as public| Cache[("Shared Cache Storage")]\n Attacker["Attacker (Unauthenticated)"] -->|5. GET /profile| Proxy\n Proxy -->|6. Checks Cache: Match Fails due to ' authorization' whitespace mismatch| Cache\n Proxy <--|7. Serves Cached Authenticated Response| Attacker\n\n\nFirst, an authenticated user (the victim) initiates a request to the application containing their authentication credentials. The upstream server returns the restricted content accompanied by the malformed Cache-Control header. Due to the parsing flaw, undici saves the response in the shared cache, ignoring the directive that restricts caching of the Authorization header's content.\n\nSecond, the attacker sends an unauthenticated request for the same endpoint. The proxy retrieves the cached response belonging to the victim. Because the security check fails to identify the cached response as private, the server returns the sensitive, authenticated data directly to the unauthenticated attacker.

Impact Assessment

The CVSS v3.1 score for CVE-2026-14643 is assessed at 5.9 (Medium Severity). The vulnerability has a high confidentiality impact because it allows unauthorized third parties to retrieve session tokens, personal details, or sensitive transaction records. It does not directly compromise system integrity or service availability, leading to a score of none for those metrics.\n\nThe attack complexity is rated as high. This classification reflects the multiple operational prerequisites needed to trigger the flaw, including the active shared cache configuration, exact request path overlap, and specific whitespace patterns generated by the upstream service. However, because no prior privileges or user interaction are required, the entry point for exploitation remains accessible to any network-based actor.\n\nEPSS data indicates a low overall probability of exploit automation in the wild, sitting at approximately 0.23%. This rating is consistent with the lack of active exploitation reports in CISA's Known Exploited Vulnerabilities (KEV) catalog. Nonetheless, in environments where Node.js microservices act as reverse proxies or API gateways using undici, the risk of silent data leakage remains a significant concern.

Mitigation & Remediation

The primary remediation path is upgrading the undici dependency within the application. For deployments relying on the 7.x release train, the package must be updated to version 7.29.0 or higher. For deployments using the 8.x branch, the dependency must be updated to version 8.9.0 or higher.\n\nIf an immediate dependency upgrade is impossible due to breaking changes or legacy constraints, several temporary workarounds can mitigate the risk. Network administrators can configure reverse proxies or application delivery controllers (such as Nginx, Cloudflare, or AWS CloudFront) to strip or sanitize whitespace inside Cache-Control headers before they reach the Node.js application. This prevents the parser from encountering malformed inputs.\n\nAdditionally, developers can temporarily disable the Cache Interceptor or reconfigure it to run in private caching mode. This modification prevents the storage of shared cache records entirely, neutralizing the vector of cross-user information disclosure at the cost of increased upstream traffic.

Official Patches

Node.js / UndiciMain branch fix commit
Node.js / UndiciCherry-pick patch commit

Fix Analysis (2)

Technical Appendix

CVSS Score
5.9/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N
EPSS Probability
0.23%
Top 86% most exploited
12,000
via Shodan

Affected Systems

Applications utilizing Node.js undici client with Cache Interceptor enabled in shared mode

Affected Versions Detail

Product
Affected Versions
Fixed Version
undici
Node.js / OpenJS Foundation
>= 7.0.0 < 7.29.07.29.0
undici
Node.js / OpenJS Foundation
>= 8.0.0 < 8.9.08.9.0
AttributeDetail
CWE IDCWE-436 / CWE-524
Attack VectorNetwork (AV:N)
CVSS v3.1 Score5.9 (Medium)
EPSS Score0.00229
ImpactConfidentiality (High)
Exploit StatusProof-of-Concept (PoC)
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1119Automated Collection
Collection
T1539Steal Web Session Cookie
Credential Access
CWE-436
Interpretation Conflict

The product does not properly neutralize whitespace differences when comparing structured elements, leading to interpretation discrepancies.

Known Exploits & Detection

Unit Test in Commit 85a240551c9feb8b8a0ecc56c84b2b3015add8a9Unit tests validating correct behavior of whitespace trimmed fields inside the Cache-Control parsing utility

Vulnerability Timeline

Security fix developed and committed to the main branch
2026-06-11
CVE-2026-14643 published in the CVE registry
2026-07-29
GHSA-jr45-8vmc-qm54 public advisory released by Node.js/Undici maintainers
2026-07-29
National Vulnerability Database (NVD) entry updated and CVSS score established
2026-07-30

References & Sources

  • [1]NVD Vulnerability Details
  • [2]GitHub Security Advisory GHSA-jr45-8vmc-qm54
  • [3]OpenJSF Security Advisories
  • [4]CVE-2026-14643 on CVE.org
Related Vulnerabilities
CVE-2026-9678

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

•3 minutes ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.

Alon Barad
Alon Barad
0 views•10 min read
•about 1 hour 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
2 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