Oct 1, 2026·7 min read·25 visits
Fastify fails to compile validation schemas configured as boolean 'false', causing 'deny-all' schemas to be completely ignored. Unauthenticated remote attackers can bypass payload validation and execute backend route handlers.
CVE-2026-84469 is a high-severity request validation bypass vulnerability in the Fastify Node.js web framework. In versions prior to 5.12.2, Fastify uses loose truthiness checks to decide whether to compile request schemas. When a component (such as the body) is explicitly configured with a boolean 'false' schema—which under JSON Schema Draft 7 acts as a 'deny-all' constraint—Fastify's internal logic evaluates this as a falsy value and skips compilation entirely. This allows unauthenticated remote attackers to send arbitrary payloads to these endpoints, bypassing validation checks and directly executing backend route handlers.
Fastify is a widely adopted, high-performance web framework for the Node.js ecosystem. It relies heavily on schema-based compilation to perform high-speed input validation and serialization. In Fastify, route definitions can incorporate explicit JSON Schemas to validate components of incoming HTTP requests, such as headers, query parameters, route parameters, and the body. These validation layers act as a primary security boundary, protecting the underlying handler logic from malformed or unexpected data structures.
Under the JSON Schema Draft 7 specification, a schema can be declared as a boolean value. While a schema of true allows any input, a schema of false acts as a strict "deny-all" constraint. Developers frequently employ false schemas to secure endpoints, ensuring that specific parts of a request, such as query parameters or POST request bodies, are completely disabled and rejected.
This vulnerability, cataloged as CVE-2026-84469, is a high-severity request validation bypass. It occurs because the framework evaluates schema definitions using loose JavaScript truthiness checks. Because the boolean false is falsy in JavaScript, Fastify treats an explicitly defined false schema as missing or omitted. Consequently, the compiler fails to register the validation logic, and the framework executes the target route handler with unvalidated client input.
The root cause of CVE-2026-84469 lies in how Fastify's internal initialization engine detects the presence of schema definitions within lib/route.js, lib/schemas.js, and lib/validation.js. During the registration phase of an HTTP route, Fastify constructs its validation architecture by checking for defined properties on the route configuration's schema object.
In vulnerable versions of Fastify, the framework used implicit JavaScript truthiness operators (such as opts.schema.body || opts.schema.headers or if (schema.body)) to establish whether a specific schema compiled. In JavaScript, several values are treated as "falsy", including false, 0, "", null, undefined, and NaN. Because the JSON Schema Draft 7 specification defines the literal boolean false as a valid "deny-all" schema, developers setting a schema block to false expected Fastify to compile a validator that rejects all incoming requests.
However, during execution, the falsy nature of false caused Fastify to bypass the initialization of the validation compiler. The conditional statement evaluated the explicitly defined schema as absent. As a result, the framework did not bind any validator to the request handler, allowing the engine to parse arbitrary client-supplied payloads and pass them directly to the backend handler.
To understand the structural flaw, we can examine the vulnerable implementation in lib/route.js and compare it with the updated logic applied in the official fix.
Prior to the patch, lib/route.js determined if a route required schema compilation using the following validation check:
// Vulnerable pattern in lib/route.js
const hasValidationSchema = opts.schema.body ||
opts.schema.headers ||
opts.schema.querystring ||
opts.schema.paramsIf a developer configured a route to reject all body content by specifying opts.schema.body = false, and did not specify other schemas, hasValidationSchema evaluated to false. This skipped the invocation of schemaController.setupValidator().
The official patch (7de6e81697778f9f41bd327a3b1c5c9a0d9637b4) resolved this by replacing the logical OR (||) checks with explicit undefined checks.
// Patched pattern in lib/route.js
const hasValidationSchema = opts.schema.body !== undefined ||
opts.schema.headers !== undefined ||
opts.schema.querystring !== undefined ||
opts.schema.params !== undefinedThis modification ensures that any value other than undefined—including the boolean false—is treated as a present schema configuration, forcing Fastify to initialize and execute the validation engine.
Exploitation of this vulnerability requires no specialized tools or prior authentication. It relies entirely on sending well-formed requests to routes that developers configured with boolean false schemas to block input.
Consider an application endpoint designed to trigger an action without receiving external parameters, such as a GET request that uses querystring: false to enforce strict isolation:
fastify.get('/api/trigger', {
schema: {
querystring: false
}
}, async (request, reply) => {
if (request.query.force === 'true') {
runPrivilegedTask();
}
return { status: "Success" };
});In a vulnerable Fastify instance, sending a request to /api/trigger?force=true bypasses the query parameter validation. Fastify skips compilation of the query parser's validator, processes the query parameter, populates the request.query object, and runs the handler. The handler executes runPrivilegedTask() because the input is processed without hindrance.
To verify this vulnerability, an attacker can transmit an arbitrary payload to a target route that explicitly restricts that request component. If the server processes the request with an HTTP 200 OK status and executes the corresponding backend code instead of returning an HTTP 400 Bad Request code, the application is confirmed to be vulnerable.
The security impact of CVE-2026-84469 is significant for applications that rely on schemas to enforce strict data boundaries or to disable specific operational features. While the vulnerability does not directly lead to remote code execution at the framework layer, it completely removes the input validation layer.
This bypass can lead to downstream vulnerabilities, such as SQL Injection, NoSQL Injection, or Path Traversal, if the target route handlers assume that the incoming input is pre-validated or entirely absent. For example, if a developer configures an endpoint with body: false and executes dangerous commands based on fields within the body (under the assumption that those fields can never reach the handler), an attacker can supply malicious payloads to trigger those operations.
The Common Vulnerability Scoring System (CVSS) v3.1 assigns this flaw a base score of 7.5 (High), reflecting a high integrity impact and low exploitation complexity. Because the attack requires no privileges or user interaction and can be executed remotely over the network, it presents an attractive vector for targeting applications that leverage boolean-based security configurations.
The primary and recommended mitigation is to update the Fastify dependency to version 5.12.2 or higher. This update alters the validation initialization path to perform strict presence checks rather than loose truthiness checks, ensuring that boolean schemas are correctly compiled and enforced.
If upgrading is not immediately possible, security teams can implement a temporary workaround by replacing all occurrences of false schemas with explicit validation schemas that reject all input. For instance, developers can configure the schema to reject any property by setting additionalProperties to false and requiring an impossible field:
schema: {
body: {
type: 'object',
properties: {
denyAllField: { type: 'string', minLength: 999999 }
},
required: ['denyAllField'],
additionalProperties: false
}
}An alternative workaround is the implementation of application-level hooks. A preValidation hook can be registered globally or on specific routes to inspect incoming payloads and manually reject them with an HTTP 400 response:
fastify.addHook('preValidation', async (request, reply) => {
if (request.body !== undefined && request.body !== null) {
reply.code(400).send({ error: 'Bad Request', message: 'Payloads are not permitted on this route' });
}
});The fix implemented in Fastify version 5.12.2 is structurally complete. By validating the presence of the schema properties using strict inequality operators (!== undefined), it completely covers all boolean values, preventing similar truthiness bypasses.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Fastify Fastify | >= 0.1.0, < 5.12.2 | 5.12.2 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-20: Improper Input Validation |
| Attack Vector | Network (Remote) |
| CVSS Score | 7.5 (High) |
| EPSS Score | 0.00492 (Percentile: 39.86%) |
| Impact | Validation Bypass / Integrity Compromise |
| Exploit Status | PoC Available |
| KEV Status | Not Listed |
The product does not validate or incorrectly validates input that can affect the control flow or data flow of a program.
CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.
CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.
An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.
CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.
CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.
A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.