Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-106104 Overview
CVE-2026-106104 is a regular expression denial-of-service (ReDoS) vulnerability in Quasar Framework, a popular toolkit for building Vue.js applications. The flaw affects Platform.parseSSR() in ui/src/plugins/platform/Platform.js, which processes the User-Agent request header through browser-detection regular expressions that exhibit super-linear backtracking. Because Platform is registered in autoInstalledPlugins, this parsing executes before routing on every server-side rendering (SSR) request. An unauthenticated attacker can send a crafted header that stalls the Node.js event loop and delays every concurrent SSR request. The issue is fixed in Quasar version 2.23.3.
Critical Impact
A single unauthenticated HTTP request can block the Node.js event loop, degrading availability for every user of a Quasar SSR deployment.
Affected Products
- Quasar Framework versions prior to 2.23.3 running in SSR mode
- Node.js applications using Platform.parseSSR() for browser detection
- Any SSR deployment that exposes autoInstalledPlugins to unauthenticated traffic
Discovery Timeline
- 2026-10-06 - CVE-2026-106104 published to NVD
- 2026-10-06 - Last updated in NVD database
- Fix released - Quasar Framework version 2.23.3 published on GitHub
Technical Details for CVE-2026-106104
Vulnerability Analysis
The vulnerability is categorized under [CWE-1333] (Inefficient Regular Expression Complexity). Platform.parseSSR() forwards the full User-Agent header to getMatch(), which applies a chain of browser-detection expressions. These expressions combine greedy captures with repeated unbounded scans, producing catastrophic backtracking when the input contains many repeated version tokens without a terminating Safari token.
Because Platform is part of autoInstalledPlugins, the regex evaluation runs synchronously on every inbound SSR request before Quasar's router sees the request. The single-threaded Node.js event loop stalls during this backtracking window, pausing all other request handling until the regex engine returns. Only SSR targets are affected; SPA, PWA, Electron, Cordova, Capacitor, browser-extension, and static-site-generation builds do not parse an attacker-controlled request header through this path.
Root Cause
The root cause is unbounded input length combined with poorly bounded alternation and quantifiers inside the user-agent matcher. No length cap existed on the User-Agent string before matching, and the greedy pattern explored exponential state transitions on adversarial input.
Attack Vector
The attack vector is network-based and unauthenticated. An attacker sends an HTTP request with a crafted User-Agent header containing repeated version tokens and omitting the Safari terminator. Repeating this request produces sustained denial-of-service against the SSR process.
// Patch excerpt from ui/src/plugins/platform/Platform.js
let preHydrationBrowser
// Long User-Agent values are not useful for platform detection and can make
// complex browser expressions prohibitively expensive.
const maxUserAgentLength = 512
function normalizeUserAgent(userAgent) {
return typeof userAgent === 'string'
? userAgent.slice(0, maxUserAgentLength).toLowerCase()
: ''
}
function getSafariMatch(userAgent) {
const versionMatch = /(?:^|\s)version\/([\w.]+)/.exec(userAgent)
return versionMatch !== null &&
/(?:^|\s)applewebkit\/[\w.]+/.test(userAgent) &&
/(?:^|\s)safari\/[\w.]+/.test(userAgent)
? {
browser: 'safari',
version: versionMatch[1]
}
: null
}
Source: Quasar GitHub Commit 7a954dd
The patch introduces a 512-character cap on the User-Agent string and rewrites the browser matchers using anchored, non-overlapping expressions to prevent catastrophic backtracking.
Detection Methods for CVE-2026-106104
Indicators of Compromise
- HTTP requests containing abnormally long User-Agent headers, often exceeding 1 KB
- User-Agent values with long sequences of repeated version/ tokens and no Safari/ substring
- Spikes in SSR response latency correlated with specific source IPs or header fingerprints
Detection Strategies
- Inspect reverse-proxy and load-balancer logs for requests whose User-Agent header length exceeds operational norms (for example, above 512 bytes).
- Alert on Node.js event-loop lag metrics such as nodejs_eventloop_lag_seconds sustained above 100 ms during request processing.
- Compare traffic patterns against known browser User-Agent baselines to flag malformed version-token repetition.
Monitoring Recommendations
- Instrument the SSR process with event-loop monitoring (for example, perf_hooks.monitorEventLoopDelay) and export metrics to your observability stack.
- Forward web server access logs into a central analytics platform such as the Singularity Data Lake to correlate header anomalies with latency outliers.
- Track per-source request rates to identify low-volume attackers using single crafted requests for amplified impact.
How to Mitigate CVE-2026-106104
Immediate Actions Required
- Upgrade Quasar Framework to version 2.23.3 or later across all SSR deployments.
- Enforce a User-Agent header length limit at the reverse proxy or CDN layer before traffic reaches Node.js.
- Rate-limit unauthenticated requests to SSR endpoints to reduce denial-of-service amplification.
Patch Information
The fix is published in Quasar Release v2.23.3 and documented in GitHub Security Advisory GHSA-68jq-fhch-4xq4. The patch truncates the User-Agent to 512 characters via normalizeUserAgent() and replaces the vulnerable detection regex set with anchored expressions in getSafariMatch(), getOperaMatch(), and related helpers.
Workarounds
- Deploy an NGINX or Envoy rule that rejects requests where User-Agent exceeds 512 bytes.
- Switch non-SSR builds (SPA, PWA, static site generation) where feasible, since those targets do not evaluate the attacker-controlled header through this path.
- Place a web application firewall rule in front of the SSR tier to drop headers containing more than a small number of repeated version/ tokens.
# NGINX example: cap User-Agent length and reject oversized headers
http {
map $http_user_agent $ua_too_long {
default 0;
"~^.{513,}$" 1;
}
server {
listen 443 ssl;
if ($ua_too_long) {
return 400;
}
location / {
proxy_pass http://quasar_ssr_upstream;
}
}
}
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

