nuxt-nitro-server

Ecosystem: npm

Downloads:

Vulnerabilities from the last (months)
  • 0CriticalAffects 0 versions
  • 0HighAffects 0 versions
  • 0MediumAffects 0 versions
  • 5ModerateAffects 8 versions
  • 2LowAffects 4 versions
Severity distribution (all time)
7vulnerabilities
  • Critical0 (0.0%)
  • High0 (0.0%)
  • Medium0 (0.0%)
  • Moderate5 (71.4%)
  • Low2 (28.6%)

Monthly breakdown

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

Vulnerabilities (7)

Known vulnerabilities affecting nuxt-nitro-server, based on data from OSV.

Vulnerabilities affecting nuxt-nitro-server
IDSeveritySummaryAffected versionsPublishedSource
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.2.0, < 4.6.4
  • >= 3.20.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-r99w-jh2x-3mg9ModerateNuxt: Incomplete fix for GHSA-9v7c-q64q-vv33: a leading `//` in the request path bypasses `server/middleware` path checks and server route rules on page routes### Summary Since `4.6.0`, Nuxt parses a request path that starts with `//` as a URL with a host before rendering a page, so `//x/admin` renders the page at `/admin`. Nitro's routing, Nitro's route rules and `server/middleware` see the path as `//x/admin`, so server-side checks keyed on `/admin` do not apply. The fix for [GHSA-9v7c-q64q-vv33](https://github.com/nuxt/nuxt/security/advisories/GHSA-9v7c-q64q-vv33) in `4.6.3` covered dot segments but not this form. ### Impact An unauthenticated attacker can bypass server-side controls that match on the request path of a page route. A route-sco
  • >= 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-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.2.0, < 4.6.2
  • >= 3.20.0
GitHub (opens in a new tab)
GHSA-hg3f-28rg-4jxjModerateNuxt's route middleware is not enforced when rendering `.server.vue` pages via `/__nuxt_island/page_*`### Summary When `experimental.componentIslands` is enabled (default in Nuxt 4), any `.server.vue` file under `pages/` is automatically registered as a server island under the key `page_<routeName>` and exposed via the `/__nuxt_island/:name` endpoint. Until this fix, requests through that endpoint rendered the page component directly via the SSR renderer without instantiating Vue Router, which meant route middleware declared on the page (including `definePageMeta({ middleware })`) did not run. For Nuxt applications that gate a `.server.vue` *page* behind route middleware as their sole auth c
  • >= 3.20.0, < 3.21.6
  • >= 4.2.0, < 4.4.6
GitHub (opens in a new tab)
GHSA-g8wj-3cr3-6w7vLowNuxt: `__nuxt_island` endpoint does not bind responses to request props, enabling shared-cache poisoning### Summary The `/__nuxt_island/*` endpoint accepts attacker-controlled `props` query/body parameters and renders any island component without verifying that the URL-resident hash (`<Name>_<hashId>.json`) was actually issued for those inputs by `<NuxtIsland>`. The hash is computed and embedded client-side but never validated server-side, so the same path can return materially different responses depending on the query. Island components are documented as rendering independently of route context - page middleware does not apply to them, and they are intentionally cacheable as a function of th
  • >= 3.20.0, < 3.21.6
  • >= 4.2.0, < 4.4.6
GitHub (opens in a new tab)
  • 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.2.0, < 4.6.4
    • >= 3.20.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-r99w-jh2x-3mg9Moderate
    Nuxt: Incomplete fix for GHSA-9v7c-q64q-vv33: a leading `//` in the request path bypasses `server/middleware` path checks and server route rules on page routes
    • >= 4.6.0, < 4.6.4

    ### Summary Since `4.6.0`, Nuxt parses a request path that starts with `//` as a URL with a host before rendering a page, so `//x/admin` renders the page at `/admin`. Nitro's routing, Nitro's route rules and `server/middleware` see the path as `//x/admin`, so server-side checks keyed on `/admin` do not apply. The fix for [GHSA-9v7c-q64q-vv33](https://github.com/nuxt/nuxt/security/advisories/GHSA-9v7c-q64q-vv33) in `4.6.3` covered dot segments but not this form. ### Impact An unauthenticated attacker can bypass server-side controls that match on the request path of a page route. A route-sco

    CVE: CVE-2026-128077

  • 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-vjh5-4x84-xrqpModerate
    Nuxt: Server-side route rules (`redirect`, `headers`, `proxy`, `ssr`) are skipped for case-variant paths when routing is case-insensitive
    • >= 4.2.0, < 4.6.2
    • >= 3.20.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-hg3f-28rg-4jxjModerate
    Nuxt's route middleware is not enforced when rendering `.server.vue` pages via `/__nuxt_island/page_*`
    • >= 3.20.0, < 3.21.6
    • >= 4.2.0, < 4.4.6

    ### Summary When `experimental.componentIslands` is enabled (default in Nuxt 4), any `.server.vue` file under `pages/` is automatically registered as a server island under the key `page_<routeName>` and exposed via the `/__nuxt_island/:name` endpoint. Until this fix, requests through that endpoint rendered the page component directly via the SSR renderer without instantiating Vue Router, which meant route middleware declared on the page (including `definePageMeta({ middleware })`) did not run. For Nuxt applications that gate a `.server.vue` *page* behind route middleware as their sole auth c

    CVE: CVE-2026-47200

  • GHSA-g8wj-3cr3-6w7vLow
    Nuxt: `__nuxt_island` endpoint does not bind responses to request props, enabling shared-cache poisoning
    • >= 3.20.0, < 3.21.6
    • >= 4.2.0, < 4.4.6

    ### Summary The `/__nuxt_island/*` endpoint accepts attacker-controlled `props` query/body parameters and renders any island component without verifying that the URL-resident hash (`<Name>_<hashId>.json`) was actually issued for those inputs by `<NuxtIsland>`. The hash is computed and embedded client-side but never validated server-side, so the same path can return materially different responses depending on the query. Island components are documented as rendering independently of route context - page middleware does not apply to them, and they are intentionally cacheable as a function of th

    CVE: CVE-2026-46342

Showing 1-7 of 7 vulnerabilities