Skip to main content

@fastify/static EUVDEUVD-2026-54086

| CVE-2026-18427 HIGH
Path Traversal (CWE-22)
2026-08-06 openjs
7.5
CVSS 3.1 · Vendor: openjs
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify Fastify app with route-based static guard
  2. Delivery
    Craft non-canonical URL using encoded dots, backslashes, or duplicate slashes
  3. Exploit
    Send unauthenticated HTTP GET request
  4. Execution
    Route matcher sees unguarded path, bypass succeeds
  5. Persist
    send layer resolves canonical filesystem path
  6. Impact
    Protected static file contents returned to attacker

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK

2 techniques across 2 tactics: Discovery, Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires two conditions to be simultaneously true: the target must run @fastify/static in a version prior to 10.1.3, AND the application must protect a subtree of the static root using a route-based guard (a Fastify route plugin, hook, or middleware that restricts access based on URL prefix). Applications using only the allowedPath option are explicitly not vulnerable per the vendor advisory. The attacker must be able to reach the Fastify HTTP endpoint over the network; no authentication is required (PR:N per CVSS vector) and no user interaction is needed. Exploitation is bounded by the guard mechanism: only route-based guards are bypassed; OS-level file permissions, allowedPath logic, or upstream reverse proxy normalization remain effective barriers. If no route-based guard is configured, the attack surface does not exist.

Impact

The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, score 7.5) accurately reflects the threat: network-reachable, low complexity, no authentication, high confidentiality impact, with no integrity or availability consequence and unchanged scope. The real-world risk is meaningfully conditional: only applications that protect a static subtree using a route-based guard (not the allowedPath option) are exposed - a significant narrowing factor. No CISA KEV listing and no public POC exist at time of analysis, and EPSS data was not provided so exploitation probability cannot be quantified. However, path normalization bypass is an extremely well-documented class of attack requiring no specialized knowledge, which lowers the practical bar substantially. The net assessment is a genuine high priority for affected configurations - route-guard-protected Fastify deployments should patch immediately - but not universally critical, as allowedPath users are explicitly exempt. There is no conflict between CVSS signals and the description; both align on unauthenticated network access with disclosure-only impact.

Exploit ScenarioDerived

An attacker identifies a Fastify application serving static files where a route-based guard restricts access to a path such as /private/. By sending a crafted GET request using a non-canonical path form - for example, GET /%2Eprivate/secret.json or GET /public/../private/secret.json with encoded or duplicated segments - the routing layer matches a different, unguarded route while the send library resolves the canonical path and serves the protected file's contents. No authentication or prior access is required, and no public POC exists at time of analysis, though the technique is widely understood.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 06, 2026

Route guard bypass in @fastify/static before 10.1.3 exposes protected static files to unauthenticated remote attackers without requiring any credentials. The plugin failed to canonicalize non-standard path forms - including dot segments, duplicate slashes, percent-encoded dots, and backslashes - before matching the request path against route-based guards, allowing crafted URLs to evade the guard while the underlying send layer resolves and serves the protected file. This is an incomplete fix for a prior vulnerability in the same component; no public exploit identified at time of analysis, though the technique is a textbook path normalization bypass requiring no advanced skills.

RemediationAI

Upgrade @fastify/static to version 10.1.3 or later, which canonicalizes request pathnames - including backslash rejection - before both route matching and file serving, closing the guard bypass entirely. The vendor advisory at https://github.com/fastify/fastify-static/security/advisories/GHSA-423g-23ch-w7c6 confirms this as the authoritative fix. If immediate patching is not feasible, migrate route-based guards to the allowedPath option, which the vendor explicitly identifies as not affected by this vulnerability; note that allowedPath operates on resolved file paths rather than URL routes and may require application logic adjustments to replicate the same access policy. As an additional compensating control, configure an ingress reverse proxy (nginx, Caddy) to normalize request paths before forwarding to Fastify, or deploy a WAF rule that rejects requests containing percent-encoded dots (%2E), double slashes, or backslashes - both approaches have low side-effect risk for most applications but add operational complexity and should not replace patching.

Affected VersionsENISA

@fastify/static 0 <10.1.3

Affected Packages

euvd fastify_static fix: 10.1.3

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The vulnerability is rooted in CWE-22 (Path Traversal) and specifically in a path canonicalization gap between two processing layers: the Fastify route-matching layer and the send file-serving library. @fastify/static is the official static file plugin for the Fastify Node.js web framework; it delegates actual file serving to the send library. The previous incomplete fix rejected parent-directory segments (../) but did not normalize dot segments (.), duplicate slashes (//), percent-encoded dots (%2E), or Windows-style backslashes before route matching. Because the HTTP routing layer and the filesystem resolver handle these non-canonical forms differently, a crafted URL can appear as a distinct, unguarded path to the route matcher while resolving identically to the protected file on disk. The CPE (cpe:2.3:a:@fastify/static:@fastify/static:*:*:*:*:*:*:*:*) covers all versions prior to the fix. Version 10.1.3 addresses this by applying full pathname canonicalization - including explicit backslash rejection - before both routing and send delegation.

Know when Fastify Static gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (openjs) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
vuln.today AI 7.5 HIGH

Network-reachable with no authentication required; impact is file disclosure only (C:H, I:N, A:N); scope unchanged as no system boundary is crossed.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
Red Hat 7.5 HIGH

Primary rating from Vendor (openjs).

CVSS VectorVendor: openjs

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
None

Lifecycle Timeline

2
Patch available
Aug 06, 2026 - 16:17 EUVD
CVE Published
Aug 06, 2026 - 14:52 cve.org
HIGH 7.5

DescriptionCVE.org

@fastify/static before version 10.1.3 contains an incomplete fix for a previous route guard bypass. The static file handler rejected only parent directory segments, but it did not canonicalize dot segments, duplicate slashes, encoded dots, or backslashes before route matching and before delegating to the send layer. As a result, an unauthenticated attacker could request a file protected by a route based guard using a non canonical path form that misses the guarded route yet resolves back onto the protected file, disclosing its contents. Applications that protect a subtree of the static root with a route based guard are affected, while applications relying on the allowedPath option are not. This is fixed in @fastify/static 10.1.3, which canonicalizes the pathname, including rejecting backslashes, on the path used for routing and serving.

Executive ViewAI

Why It Matters

@fastify/static before version 10.1.3 contains a route guard bypass that exposes protected static files to unauthenticated attackers without requiring credentials. Any organization running applications with this library risks unauthorized access to sensitive static assets, configuration data, or private content. Immediate inventory and mitigation of deployed instances is critical to prevent data exposure.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: deploy path canonicalization middleware upstream of @fastify/static to normalize all file path forms (dots, slashes, percent-encoding, backslashes) before route evaluation; enforce authentication for static file endpoints via reverse proxy or WAF rules; restrict accessible directory scope to only non-sensitive static content.

Threat Intelligence Overview

EPSS Score
0.5%
Top 63% exploitable
Prevalence
Medium
popular Node.js/Fastify ecosystem plugin, not universally deployed
Social Media
1
Sightings
Data Quality
8 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy