Skip to main content
Vulnerability Database/CVE-2026-106104

CVE-2026-106104: Quasar Framework DOS Vulnerability

CVE-2026-106104 is a denial of service flaw in Quasar Framework that allows attackers to block the Node.js event loop through crafted User-Agent headers. This post explains its impact, affected versions, and mitigation steps.

Published:

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.

javascript
// 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.
bash
# 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

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.