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

CVE-2026-114132: Nuxt Framework Auth Bypass Vulnerability

CVE-2026-114132 is an authentication bypass flaw in Nuxt Framework that allows attackers to skip security rules through case-sensitive routing mismatches. 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-114132 Overview

Nuxt, an open-source web development framework for Vue.js, contains a route-matching inconsistency prior to version 4.6.2. Nuxt resolves pages case-insensitively by default, while Nitro matches server-side route-rule keys case-sensitively. A request whose path differs only by letter case renders the page without the server rule intended for that route. The mismatch can skip redirect, headers, proxy, ssr: false, and noScripts directives. Calls to getRouteRules(event) and matchRouteRules return no rule for the case variant. The weakness is tracked as [CWE-178: Improper Handling of Case Sensitivity].

Critical Impact

Attackers can request routes with alternate letter casing to bypass server-side route rules, including redirects, security headers, proxy rules, and SSR configuration.

Affected Products

  • Nuxt framework versions prior to 4.6.2
  • Nuxt applications relying on Nitro server-side route rules
  • Applications without router.options.sensitive: true set in nuxt.config

Discovery Timeline

  • 2026-10-21 - CVE-2026-114132 published to NVD
  • 2026-10-22 - Last updated in NVD database

Technical Details for CVE-2026-114132

Vulnerability Analysis

The vulnerability arises from inconsistent case-sensitivity handling between two Nuxt subsystems. The Vue Router layer resolves pages case-insensitively by default, so /Admin and /admin map to the same page component. The Nitro server layer matches route-rule keys case-sensitively, so a rule declared for /admin does not apply to a request for /Admin. The result is a route that renders normally while skipping any server rule tied to the lowercase path.

Setting router.options.sensitive: true inside nuxt.config prevents the bypass. Setting the same option only in app/router.options.ts is insufficient because the server reads the nuxt.config value during build. Access checks implemented in server middleware, page route middleware, or page data fetching operate outside this matcher and remain enforced.

Root Cause

The root cause is a configuration mismatch between the page resolver and the Nitro route-rule matcher. Nitro keys rules by exact string path and does not normalize incoming request paths before lookup. When the page router accepts case variants but the rule matcher does not, the two components disagree on which rules apply to a given request.

Attack Vector

An unauthenticated remote attacker sends an HTTP request to an affected route using alternate letter casing. The server renders the page content while bypassing route rules intended to transform or restrict the response. Possible outcomes include missing security headers, skipped redirects, bypassed proxy rules, and rendering of pages the operator intended to serve as ssr: false or noScripts.

typescript
// Patch excerpt: packages/nitro-server/src/index.ts
import { template as defaultSpaLoadingTemplate } from './templates/spa-loading-icon.ts'
// TODO: figure out a good way to share this
import { createImportProtectionPatterns } from '../../nuxt/src/core/plugins/import-protection.ts'
-import { createNormalizedRouteRulesRouter, normalizeAppMiddlewareRules, resolveRouteRules } from '../../nuxt/src/core/utils/route-rules.ts'
+import { createNormalizedRouteRulesRouter, normalizeAppMiddlewareRules, normalizePathCode, resolveRouteRules } from '../../nuxt/src/core/utils/route-rules.ts'
import { unifyDynamicRouteRuleSegments } from './route-rules.ts'

Source: GitHub Commit f6cfee5

The patch introduces normalizePathCode and a normalizeRouteRulePath export, enabling the Nitro layer to match route rules case-insensitively unless the router is explicitly configured as sensitive.

Detect Identity Attacks the Moment Authentication Fails

Singularity™ Identity surfaces credential misuse, lateral movement, and privilege escalation in real time, so you can contain the breach before it spreads.

Stop Identity Attacks

Detection Methods for CVE-2026-114132

Indicators of Compromise

  • HTTP access logs showing requests to known routes using unusual letter casing, for example /Admin, /aDmin, or /ADMIN against sites that normally use /admin.
  • Responses to case-variant paths that are missing expected security headers defined in routeRules.
  • Requests to ssr: false routes that return server-rendered HTML instead of the SPA shell.
  • Successful requests reaching routes that should have been redirected or proxied by Nitro rules.

Detection Strategies

  • Compare request paths against the canonical lowercase route table and flag any case mismatches reaching protected routes.
  • Audit application routeRules configuration and generate test requests with varied casing to confirm rules apply uniformly.
  • Inspect response headers for routes governed by headers rules and alert when expected headers are absent.
  • Review Nitro build output for router.options.sensitive to confirm the configured value.

Monitoring Recommendations

  • Enable verbose HTTP access logging on reverse proxies and web application firewalls fronting Nuxt deployments.
  • Add anomaly detection for mixed-case paths targeting administrative or sensitive routes.
  • Monitor outbound responses for security header regressions on known-protected routes.

How to Mitigate CVE-2026-114132

Immediate Actions Required

  • Upgrade Nuxt to version 4.6.2 or later across all production and staging environments.
  • If upgrading is not immediately feasible, set router.options.sensitive: true inside nuxt.config to enforce case-sensitive matching.
  • Audit all routeRules entries and ensure authorization is enforced by server middleware rather than relying solely on route rules.
  • Normalize incoming paths to lowercase at the reverse proxy or CDN layer for applications that treat routes as case-insensitive.

Patch Information

The fix is included in Nuxt 4.6.2. Reference materials: GitHub Release v4.6.2, GitHub Security Advisory GHSA-vjh5-4x84-xrqp, and patch commit f6cfee5. The commit adds normalizeRouteRulePath so Nitro matches route rules case-insensitively unless the router is configured as sensitive.

Workarounds

  • Set router.options.sensitive: true in nuxt.config so the server and client both match routes case-sensitively.
  • Reimplement sensitive access checks in server middleware or server routes, independent of routeRules.
  • Add a reverse-proxy rewrite that lowercases request paths before forwarding traffic to the Nuxt application.
bash
# nuxt.config.ts mitigation example
export default defineNuxtConfig({
  router: {
    options: {
      sensitive: true
    }
  }
})

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.