Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach standalone-engine HTTP endpoint
-
DeliverySend request with malformed percent-encoding
-
ExploitDecoder throws in normalize step
-
ExecutionException escapes middie.run
-
PersistNode.js process terminates
-
ImpactDenial of service until restart
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception handling completeness
|
| Exploitation Conditions | Exploitation requires that the target application call middie.run directly on the @fastify/middie standalone engine API (versions 9.1.0-9.3.2) - this specific deployment mode is the essential precondition. The attack itself needs only a single crafted request path containing a malformed percent-encoded sequence (an incomplete percent escape or truncated multibyte sequence); no authentication (PR:N), no user interaction (UI:N), and no non-default network setup are needed once the standalone engine is in use. The primary limiting factor is that applications using the Fastify plugin path are NOT vulnerable, because Fastify's error handler catches the exception - substantially narrowing the real-world exposed population. |
| Impact | The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) is credible: exploitation is network-reachable, low-complexity, unauthenticated, requires no user interaction, and impact is availability-only (no confidentiality or integrity loss). The one material caveat the raw score hides is a deployment precondition - the vulnerable code path only executes for applications that call middie.run directly on the standalone engine API, while the far more common Fastify plugin path is protected by Fastify's framework-level error handler. No EPSS score, KEV listing, or POC was supplied, so there is no evidence of active exploitation; however, the trigger is trivial (a single malformed URL), so weaponization difficulty is very low if a target is running the standalone engine. Net: a genuine high-severity availability issue for the specific standalone-engine population, but likely a small fraction of real deployments - treat as high priority where the standalone API is confirmed in use, and lower priority otherwise. |
| Exploit ScenarioDerived | An attacker who can reach an internet-facing Node.js service built on the @fastify/middie standalone engine sends a single HTTP request with a malformed path such as '/foo%' or a truncated multibyte percent sequence. The decoder throws during normalization, the exception escapes middie.run, and the Node process exits - denying service to every connected client until the app is restarted. No authentication, user interaction, or POC tooling is required, though no public exploit has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 01, 2026
Denial of service in @fastify/middie 9.1.0 through 9.3.2 lets remote unauthenticated attackers crash the Node.js process by sending request paths with malformed percent-encoded sequences. The standalone engine's URL normalization step fails to catch a synchronous decoder exception, terminating the process and taking down all connected clients until manual restart. Only applications that invoke middie.run directly on the standalone engine API are affected; there is no public exploit identified at time of analysis, and no EPSS or KEV data was provided.
RemediationAI
Vendor-released patch: upgrade to @fastify/middie 9.3.3, which is the primary and recommended fix. If an immediate upgrade is not possible, the vendor-documented workaround is to migrate from the standalone engine API (middie.run) to the Fastify plugin path, where Fastify's built-in error handler catches the thrown exception and converts it into a normal request-level error instead of a process crash - the trade-off is a code change to your middleware wiring and revalidation that behavior is unchanged. As an additional compensating control, place an upstream reverse proxy or WAF that rejects or normalizes malformed percent-encoded URLs before they reach Node, and ensure a process supervisor (pm2, systemd, container orchestrator) auto-restarts the process to limit outage duration. Refer to the advisory at https://github.com/fastify/middie/security/advisories/GHSA-qcc9-jh8q-47vh for authoritative guidance.
Affected VersionsENISA
Affected Packages
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
@fastify/middie is the Express/Connect-style middleware engine used to run middleware within the Fastify Node.js web framework, and it exposes both a Fastify plugin path and a lower-level standalone engine API. The root cause is classified as CWE-248 (Uncaught Exception): during URL normalization, the underlying percent-decoding routine throws synchronously when it encounters an incomplete percent escape (e.g. a trailing '%') or a truncated multibyte sequence, and middie's normalize step does not wrap this in a try/catch. In the standalone engine path the exception propagates up out of middie.run with no handler, so Node's default behavior terminates the entire process rather than failing a single request.
Know when Node.js 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Remote unauthenticated single malformed request triggers the crash (AV:N/AC:L/PR:N/UI:N); impact is availability-only process termination with no data exposure (C:N/I:N/A:H).
Primary rating from Vendor (openjs).
CVSS VectorVendor: openjs
Lifecycle Timeline
1DescriptionCVE.org
@fastify/middie versions 9.1.0 through 9.3.2 fail to guard the URL normalization step used by the standalone engine when incoming request paths contain malformed percent-encoded sequences. Inputs such as an incomplete percent escape or a truncated multibyte sequence cause the underlying decoder to throw synchronously, and the exception escapes the middie normalize step and terminates the Node.js process. The bypass affects applications that call middie.run directly on the standalone engine API, causing an immediate denial of service for all connected clients until restart. Applications using the Fastify plugin path are not affected because Fastifys error handler catches the exception. Patches: upgrade to @fastify/middie 9.3.3. Workarounds: migrate from the standalone engine API to the Fastify plugin path, where the framework error handler catches the exception.
Articles & Coverage 1
Executive ViewAI
@fastify/middie 9.1.0-9.3.2 contain a critical availability risk: remote attackers can terminate Node.js application processes without authentication using malformed URLs, forcing manual restarts and causing outages. Any customer-facing or internal API using Fastify's standalone engine is immediately vulnerable. This creates unplanned downtime exposure with no vendor patch available to date.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Web Application Firewall rules to reject requests with malformed percent-encoding patterns; (2) application-level URL validation before middie processing; (3) process auto-restart with health checks (PM2, Docker restart policies, systemd auto-restart); (4) enhanced monitoring and alerting on unexpected process terminations; (5) consider temporary downgrade or upgrade to unaffected versions if operationally feasible.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation
A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could
FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t
Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete
Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc
An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner
OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph
Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi
Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin
The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic
EUVD-2026-40947
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB