nuxt

Ecosystem: npm

Downloads: 13 Mln

Vulnerabilities from the last (months)
  • 2CriticalAffects 2 versions
  • 7HighAffects 12 versions
  • 0MediumAffects 0 versions
  • 17ModerateAffects 28 versions
  • 7LowAffects 12 versions
Severity distribution (all time)
33vulnerabilities
  • Critical2 (6.1%)
  • High7 (21.2%)
  • Medium0 (0.0%)
  • Moderate17 (51.5%)
  • Low7 (21.2%)

Monthly breakdown

  • Critical
  • High
  • Medium
  • Moderate
  • Low
  • 4 vulnerabilities
    • Critical: 0
    • High: 0
    • Medium: 0
    • Moderate: 3
    • Low: 1
  • 5 vulnerabilities
    • Critical: 0
    • High: 0
    • Medium: 0
    • Moderate: 4
    • Low: 1
  • 8 vulnerabilities
    • Critical: 0
    • High: 5
    • Medium: 0
    • Moderate: 3
    • Low: 0
  • 8 vulnerabilities
    • Critical: 0
    • High: 1
    • Medium: 0
    • Moderate: 4
    • Low: 3
  • 3 vulnerabilities
    • Critical: 0
    • High: 0
    • Medium: 0
    • Moderate: 2
    • Low: 1
  • 1 vulnerabilities
    • Critical: 0
    • High: 0
    • Medium: 0
    • Moderate: 0
    • Low: 1
  • 1 vulnerabilities
    • Critical: 0
    • High: 1
    • Medium: 0
    • Moderate: 0
    • Low: 0
  • 2 vulnerabilities
    • Critical: 1
    • High: 0
    • Medium: 0
    • Moderate: 1
    • Low: 0
  • 1 vulnerabilities
    • Critical: 1
    • High: 0
    • Medium: 0
    • Moderate: 0
    • Low: 0

Vulnerabilities (33)

Known vulnerabilities affecting nuxt, based on data from OSV.

Vulnerabilities affecting nuxt
IDSeveritySummaryAffected versionsPublishedSource
GHSA-96x6-fvhx-49hgModerateNuxt exposes the message and data of unhandled errors thrown during server rendering### Summary When a page, plugin or route middleware throws an error that is not an HTTP error, Nuxt wraps it with `createError` before rendering the error page. The wrapped error was treated as one the app raised deliberately, so in production its `message` and `data` were sent to the client in the error page payload (`__NUXT_DATA__`) and in JSON error responses. For a failed `$fetch`, that is the URL that was requested (including its query string) and the body of the upstream error response. ### Impact An application is affected if server-rendered code lets an error with sensitive details
  • >= 4.0.0, < 4.6.4
  • >= 3.0.0
GitHub (opens in a new tab)
GHSA-f3x9-2chm-73c8ModerateNuxt: Incomplete fix for GHSA-6gq8-jgmh-3ffp: an encoded slash (`%2F`) in the request path bypasses route rules on catch-all page routes### Summary Nuxt matches route rules against the request path with encoded slashes (`%2F`) left encoded, while the page router decodes them into route params. A request that spells a slash as `%2F` can therefore render a page through a catch-all route without the route rules configured for the path it resolves to. The fix for [GHSA-6gq8-jgmh-3ffp](https://github.com/nuxt/nuxt/security/advisories/GHSA-6gq8-jgmh-3ffp) deliberately left reserved escapes such as `%2F` encoded, so it did not cover this form. ### Impact An unauthenticated attacker can bypass route rules that protect paths served
  • >= 4.0.0, < 4.6.4
  • >= 3.0.0
GitHub (opens in a new tab)
GHSA-hf59-9xwc-2g4pLowNuxt: Colliding island props can share one `/__nuxt_island` path (incomplete fix for CVE-2026-46342)### Summary The fix for CVE-2026-46342 (GHSA-g8wj-3cr3-6w7v) binds each `/__nuxt_island/<Name>_<hash>.json` path to its props by hashing the `(name, props, context, source)` tuple. That hash was computed over `ohash`'s serialization, which does not escape quotes inside strings or delimiters inside keys, so two different prop objects can produce the same hash. A request with crafted props can therefore pass validation for another island's path and render different content at that path. ### Impact For example, these two prop objects serialize identically and share one island path: ```js { ht
  • >= 4.4.6, < 4.6.4
  • >= 3.21.6
GitHub (opens in a new tab)
GHSA-r9jc-w898-3fv6ModerateNuxt payload URL generation has quadratic cost for repeated slashes in the request path### Summary Nuxt strips trailing slashes from the request path with a regular expression whose cost grows quadratically with the length of a run of consecutive slashes. A single unauthenticated request with a long run of slashes can occupy the server's event loop for a noticeable time, delaying every other request handled by the same process. ### Impact When a page is rendered with payload extraction (any route covered by an `isr`, `swr` or `cache` route rule), Nuxt builds the `_payload.json` URL from the raw request path. A path such as `/blog/a` followed by 16,000 slashes and `x`, which f
  • >= 4.6.0, < 4.6.4
GitHub (opens in a new tab)
GHSA-9v7c-q64q-vv33ModerateNuxt: Dot segments in the request path bypass `server/middleware` path checks and server route rules on page routes### Summary Since `4.6.0`, Nuxt resolves `.` and `..` segments in the request path, including percent-encoded forms such as `%2e`, before rendering a page. Nitro's routing, Nitro's route rules and `server/middleware` see the path with those segments still in place. A request for `/%2e/admin` therefore renders the page at `/admin`, while server-side checks keyed on `/admin` do not apply. ### Impact An unauthenticated attacker can bypass server-side controls that match on the request path of a page route. `server/middleware` that checks `event.path` (or `event.node.req.url`) is skipped: ```
  • >= 4.6.0, < 4.6.3
GitHub (opens in a new tab)
GHSA-6gq8-jgmh-3ffpModerateNuxt: Route rules are matched against the raw request path, so a percent-encoded segment can bypass `appMiddleware` on dynamic and catch-all routes### Summary Nuxt compared `routeRules` keys against the raw request path, without decoding percent-encoding, while the router decodes parameters when it resolves a route. A request whose path is percent-encoded can therefore resolve to a page while failing to match the route rule meant to protect it, so the rule's `appMiddleware` never runs, including during server rendering. ### Impact For a page served through a dynamic or catch-all route, an attacker can percent-encode a character in the path to skip the rule: ```ts export default defineNuxtConfig({ routeRules: { '/users/admin': {
  • >= 4.0.0, < 4.4.4
  • >= 3.11.0, < 3.21.4
GitHub (opens in a new tab)
GHSA-jjm6-p2m9-9w4xLowNuxt: Incomplete fix for GHSA-934w-87qh-qr26: a `javascript:` URL prefixed with an ASCII control character executes from `<NuxtLink>` when `pages` is disabled## Impact An application that renders `<NuxtLink :to="...">` with a value it does not control can be made to render an anchor whose `href` executes script in the application's origin when clicked. This is an incomplete fix for [GHSA-934w-87qh-qr26](https://github.com/nuxt/nuxt/security/advisories/GHSA-934w-87qh-qr26) (CVE-2026-53722). It only affects applications running without a `pages/` directory, where `pages` resolves to `false` and Nuxt registers its own router in place of vue-router. Applications using vue-router are not affected. Prefixing `javascript:` with an ASCII C0 control char
  • < 4.6.0
GitHub (opens in a new tab)
GHSA-vjh5-4x84-xrqpModerateNuxt: Server-side route rules (`redirect`, `headers`, `proxy`, `ssr`) are skipped for case-variant paths when routing is case-insensitive## Impact With the default `router.options.sensitive: false`, Nuxt's page router resolves routes case-insensitively, so `/Admin` renders the same page as `/admin`. On the server, however, route rules were resolved with Nitro's route-rule matcher, which matches keys case-sensitively. A request whose path differs from a rule key only in letter case therefore rendered the page with none of that rule applied. Earlier fixes ([GHSA-mm7m-92g8-7m47](https://github.com/nuxt/nuxt/security/advisories/GHSA-mm7m-92g8-7m47), [GHSA-hxvh-4h3w-prp9](https://github.com/nuxt/nuxt/security/advisories/GHSA-hxvh-
  • >= 4.0.0, < 4.6.2
  • >= 3.0.0
GitHub (opens in a new tab)
GHSA-xfq5-w38q-pc2xModerateNuxt server islands render `useHeadSafe` input without sanitisation## Impact `useHeadSafe` restricts head input to an allowlist of safe tags and attributes. For example, `bodyAttrs` is limited to `class` and `style`, event handler attributes are removed, and `<script>` tags are only kept for JSON types. When `useHeadSafe` is called inside a server island (a `.server.vue` component or page, or a component rendered with `<NuxtIsland>`), the island renderer serialises the raw input of every head entry into the island response without the option that marks it as safe input. `<NuxtIsland>` then pushes that input into the page's head as a regular entry, both duri
  • >= 3.13.0, < 4.6.2
GitHub (opens in a new tab)
GHSA-4jjw-pwvw-q6w3ModerateDuplicate Advisory: Nuxt dev server discloses project root and workspace UUID via the Chrome DevTools workspace endpoint## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-7c4v-fwgw-9rf7. This link is maintained to preserve external references. ## Original Description Nuxt versions >= 4.4.7 and < 4.5.1, and >= 3.21.7 and < 3.21.10, contain an information disclosure vulnerability in the development server's Chrome DevTools workspace endpoint (GET /.well-known/appspecific/com.chrome.devtools.json). The endpoint's local-request gate (isLocalDevRequest) is header-based and trusts the attacker-supplied Host header rather than the connected peer address. When the dev server is b
  • >= 4.4.7
GitHub (opens in a new tab)
  • GHSA-96x6-fvhx-49hgModerate
    Nuxt exposes the message and data of unhandled errors thrown during server rendering
    • >= 4.0.0, < 4.6.4
    • >= 3.0.0

    ### Summary When a page, plugin or route middleware throws an error that is not an HTTP error, Nuxt wraps it with `createError` before rendering the error page. The wrapped error was treated as one the app raised deliberately, so in production its `message` and `data` were sent to the client in the error page payload (`__NUXT_DATA__`) and in JSON error responses. For a failed `$fetch`, that is the URL that was requested (including its query string) and the body of the upstream error response. ### Impact An application is affected if server-rendered code lets an error with sensitive details

    CVE: CVE-2026-128075

  • GHSA-f3x9-2chm-73c8Moderate
    Nuxt: Incomplete fix for GHSA-6gq8-jgmh-3ffp: an encoded slash (`%2F`) in the request path bypasses route rules on catch-all page routes
    • >= 4.0.0, < 4.6.4
    • >= 3.0.0

    ### Summary Nuxt matches route rules against the request path with encoded slashes (`%2F`) left encoded, while the page router decodes them into route params. A request that spells a slash as `%2F` can therefore render a page through a catch-all route without the route rules configured for the path it resolves to. The fix for [GHSA-6gq8-jgmh-3ffp](https://github.com/nuxt/nuxt/security/advisories/GHSA-6gq8-jgmh-3ffp) deliberately left reserved escapes such as `%2F` encoded, so it did not cover this form. ### Impact An unauthenticated attacker can bypass route rules that protect paths served

    CVE: CVE-2026-128071

  • GHSA-hf59-9xwc-2g4pLow
    Nuxt: Colliding island props can share one `/__nuxt_island` path (incomplete fix for CVE-2026-46342)
    • >= 4.4.6, < 4.6.4
    • >= 3.21.6

    ### Summary The fix for CVE-2026-46342 (GHSA-g8wj-3cr3-6w7v) binds each `/__nuxt_island/<Name>_<hash>.json` path to its props by hashing the `(name, props, context, source)` tuple. That hash was computed over `ohash`'s serialization, which does not escape quotes inside strings or delimiters inside keys, so two different prop objects can produce the same hash. A request with crafted props can therefore pass validation for another island's path and render different content at that path. ### Impact For example, these two prop objects serialize identically and share one island path: ```js { ht

    CVE: CVE-2026-128076

  • GHSA-r9jc-w898-3fv6Moderate
    Nuxt payload URL generation has quadratic cost for repeated slashes in the request path
    • >= 4.6.0, < 4.6.4

    ### Summary Nuxt strips trailing slashes from the request path with a regular expression whose cost grows quadratically with the length of a run of consecutive slashes. A single unauthenticated request with a long run of slashes can occupy the server's event loop for a noticeable time, delaying every other request handled by the same process. ### Impact When a page is rendered with payload extraction (any route covered by an `isr`, `swr` or `cache` route rule), Nuxt builds the `_payload.json` URL from the raw request path. A path such as `/blog/a` followed by 16,000 slashes and `x`, which f

    CVE: CVE-2026-128074

  • GHSA-9v7c-q64q-vv33Moderate
    Nuxt: Dot segments in the request path bypass `server/middleware` path checks and server route rules on page routes
    • >= 4.6.0, < 4.6.3

    ### Summary Since `4.6.0`, Nuxt resolves `.` and `..` segments in the request path, including percent-encoded forms such as `%2e`, before rendering a page. Nitro's routing, Nitro's route rules and `server/middleware` see the path with those segments still in place. A request for `/%2e/admin` therefore renders the page at `/admin`, while server-side checks keyed on `/admin` do not apply. ### Impact An unauthenticated attacker can bypass server-side controls that match on the request path of a page route. `server/middleware` that checks `event.path` (or `event.node.req.url`) is skipped: ```

    CVE: CVE-2026-119200

  • GHSA-6gq8-jgmh-3ffpModerate
    Nuxt: Route rules are matched against the raw request path, so a percent-encoded segment can bypass `appMiddleware` on dynamic and catch-all routes
    • >= 4.0.0, < 4.4.4
    • >= 3.11.0, < 3.21.4

    ### Summary Nuxt compared `routeRules` keys against the raw request path, without decoding percent-encoding, while the router decodes parameters when it resolves a route. A request whose path is percent-encoded can therefore resolve to a page while failing to match the route rule meant to protect it, so the rule's `appMiddleware` never runs, including during server rendering. ### Impact For a page served through a dynamic or catch-all route, an attacker can percent-encode a character in the path to skip the rule: ```ts export default defineNuxtConfig({ routeRules: { '/users/admin': {

    CVE: CVE-2026-114131

  • GHSA-jjm6-p2m9-9w4xLow
    Nuxt: Incomplete fix for GHSA-934w-87qh-qr26: a `javascript:` URL prefixed with an ASCII control character executes from `<NuxtLink>` when `pages` is disabled
    • < 4.6.0

    ## Impact An application that renders `<NuxtLink :to="...">` with a value it does not control can be made to render an anchor whose `href` executes script in the application's origin when clicked. This is an incomplete fix for [GHSA-934w-87qh-qr26](https://github.com/nuxt/nuxt/security/advisories/GHSA-934w-87qh-qr26) (CVE-2026-53722). It only affects applications running without a `pages/` directory, where `pages` resolves to `false` and Nuxt registers its own router in place of vue-router. Applications using vue-router are not affected. Prefixing `javascript:` with an ASCII C0 control char

    CVE: CVE-2026-114130

  • GHSA-vjh5-4x84-xrqpModerate
    Nuxt: Server-side route rules (`redirect`, `headers`, `proxy`, `ssr`) are skipped for case-variant paths when routing is case-insensitive
    • >= 4.0.0, < 4.6.2
    • >= 3.0.0

    ## Impact With the default `router.options.sensitive: false`, Nuxt's page router resolves routes case-insensitively, so `/Admin` renders the same page as `/admin`. On the server, however, route rules were resolved with Nitro's route-rule matcher, which matches keys case-sensitively. A request whose path differs from a rule key only in letter case therefore rendered the page with none of that rule applied. Earlier fixes ([GHSA-mm7m-92g8-7m47](https://github.com/nuxt/nuxt/security/advisories/GHSA-mm7m-92g8-7m47), [GHSA-hxvh-4h3w-prp9](https://github.com/nuxt/nuxt/security/advisories/GHSA-hxvh-

    CVE: CVE-2026-114132

  • GHSA-xfq5-w38q-pc2xModerate
    Nuxt server islands render `useHeadSafe` input without sanitisation
    • >= 3.13.0, < 4.6.2

    ## Impact `useHeadSafe` restricts head input to an allowlist of safe tags and attributes. For example, `bodyAttrs` is limited to `class` and `style`, event handler attributes are removed, and `<script>` tags are only kept for JSON types. When `useHeadSafe` is called inside a server island (a `.server.vue` component or page, or a component rendered with `<NuxtIsland>`), the island renderer serialises the raw input of every head entry into the island response without the option that marks it as safe input. `<NuxtIsland>` then pushes that input into the page's head as a regular entry, both duri

    CVE: CVE-2026-114133

  • GHSA-4jjw-pwvw-q6w3Moderate
    Duplicate Advisory: Nuxt dev server discloses project root and workspace UUID via the Chrome DevTools workspace endpoint
    • >= 4.4.7

    ## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-7c4v-fwgw-9rf7. This link is maintained to preserve external references. ## Original Description Nuxt versions >= 4.4.7 and < 4.5.1, and >= 3.21.7 and < 3.21.10, contain an information disclosure vulnerability in the development server's Chrome DevTools workspace endpoint (GET /.well-known/appspecific/com.chrome.devtools.json). The endpoint's local-request gate (isLocalDevRequest) is header-based and trusts the attacker-supplied Host header rather than the connected peer address. When the dev server is b

Showing 1-10 of 33 vulnerabilities