← Back to Feed CACHED · 2026-10-14 03:53:14 · CACHE_KEY CVE-2026-107832
CVE-2026-107832 · CWE-178 · Disclosed 2026-10-13

Fastify Header Validation Bypass via Case-Sensitive propertyNames Subschema

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

Like a nightclub bouncer who checks IDs by last name but forgot to ignore capitalization on the VIP list

CVE-2026-107832 affects Fastify versions 5.12.2 through 5.12.5 (fixed in 5.12.6). The vulnerability lives in Fastify's header schema validation pipeline: when a route schema uses a propertyNames subschema with enum or const to restrict which HTTP headers are allowed, the framework's lowercasing routine skips those nested values. Because Node.js normalizes all incoming header names to lowercase, a schema declaring "X-Admin-Token" (canonical case) in a propertyNames enum will *never* match the incoming "x-admin-token", so the validation constraint silently becomes a no-op. An attacker can send any header — including one the developer intended to block — and it sails through to the route handler unvalidated.

The vendor's LOW / 3.7 score is honest and well-calibrated. The CVSS vector correctly models this as network-reachable (AV:N) but high complexity (AC:H) because exploitation requires the application to use a *specific, uncommon* JSON Schema pattern (propertyNames with enum/const for header validation) *and* to have written those enum values in non-lowercase — a double niche. The impact ceiling is Low integrity with zero confidentiality or availability effect: the header reaches the handler, but what happens next is entirely application-dependent. Most Fastify apps never touch propertyNames for headers at all; the standard properties-based header schemas are unaffected. This is a real bug, not a phantom, but the blast radius is narrow.

"Niche schema pattern bypass with low integrity impact — vendor score is fair"
02 · The Attack Path

4 steps from start to impact.

STEP 01

Identify a Fastify 5.12.2–5.12.5 endpoint

The attacker locates a service running a vulnerable Fastify version. Version fingerprinting is possible via Server response headers if the app has not stripped them, or through behavioural differences in error responses. The version window is narrow — only four patch releases.
Conditions required:
  • Target runs Fastify >=5.12.2 <5.12.6
Where this breaks in practice:
  • Fastify does not expose version by default; requires probing
  • The 4-release window means many apps auto-updated past it via lockfile refresh
Detection/coverage: npm audit / Snyk / Dependabot alerts flag GHSA-389g-gv7q-r4x8 in package-lock.json
STEP 02

Discover a route using propertyNames header validation

The attacker needs a route whose schema restricts headers via a propertyNames subschema with enum or const values written in non-lowercase. This is an uncommon JSON Schema Draft 7 feature. The standard Fastify pattern uses properties with per-header schemas, which is *not* affected. Discovering the exact schema externally is non-trivial unless the app exposes it (e.g., via Swagger/OpenAPI docs).
Conditions required:
  • Route must use propertyNames (not properties) for header constraints
  • enum/const values must be non-lowercase (e.g., X-Custom-Auth)
Where this breaks in practice:
  • The vast majority of Fastify apps use properties-based header schemas — propertyNames for header allow/deny-listing is an edge pattern
  • Even apps using propertyNames may already use lowercase header names by convention, neutralising the bug
Detection/coverage: Static analysis of route schemas in source; no external scanner covers this pattern
STEP 03

Craft request with bypassed header

The attacker sends an HTTP request including the header that should have been blocked. Because Node.js lowercases it on ingress, the schema's canonical-case enum value never matches, and validation passes. The forbidden header value reaches the route handler as if no restriction existed.
Conditions required:
  • Attacker can reach the endpoint over the network
Where this breaks in practice:
  • Standard HTTP — no special tooling needed beyond curl
  • But the attacker must know *which* header to target and what value triggers the desired behaviour in the handler
Detection/coverage: WAF rules or reverse-proxy header stripping may catch specific headers regardless of backend validation
STEP 04

Exploit application-specific handler logic

The actual impact depends entirely on what the route handler does with the smuggled header. If the handler trusts the validation layer and makes authorization, routing, or data-processing decisions based on header presence/value, the attacker may influence application behaviour. However, the Fastify vulnerability itself grants no privilege escalation, RCE, or data disclosure — it only silences one validation gate.
Conditions required:
  • Handler must make security-relevant decisions based on the bypassed header
Where this breaks in practice:
  • Most applications enforce authz at a separate middleware or IdP layer, not via raw header schema validation
  • Any defence-in-depth (e.g., JWT verification, session cookies) is unaffected
Detection/coverage: Application-level audit logging of handler decisions; anomalous header patterns in access logs
03 · Compensating Control

1
LOW 3.7→IGNORE 0.0
SEVERITY REDUCED
Lowercase all header names in route schemas immediately — The root cause is a case mismatch between schema enum/const values and Node.js's lowercased headers. Rewriting propertyNames enum values to lowercase (e.g., x-admin-token instead of X-Admin-Token) fully neutralises the bypass without upgrading Fastify. This is a one-line schema change per affected route. No SLA pressure — LOW verdict means no mitigation SLA — go straight to the 365-day remediation window, but this fix is so trivial you should do it today.
2
LOW 3.7→IGNORE 0.0
SEVERITY REDUCED
Upgrade to Fastify 5.12.6 — The definitive fix. Run npm install [email protected] and deploy. The noisgate remediation SLA for LOW is 365 days, but this is a zero-breaking-change patch bump — roll it with your next scheduled dependency update.
3
LOW 3.7→LOW 2.5
Strip or normalise sensitive headers at the reverse proxy — Configure your reverse proxy (nginx, Envoy, Caddy, ALB) to strip or enforce known-good headers before they reach Fastify. This provides defence-in-depth against any header-smuggling vector, not just this CVE. Deploy within your normal change window.
4
LOW 3.7→IGNORE 0.0
SEVERITY REDUCED
Audit routes for propertyNames header validation — Run a grep or AST search (grep -rn 'propertyNames' src/routes/) to identify any route schemas using propertyNames with enum or const in header definitions. If none are found, this CVE does not apply to your application at all — document and close.
What doesn't work
  • WAF generic rules — standard WAF rulesets (OWASP CRS, AWS WAF managed rules) do not inspect whether a backend's JSON Schema validation is being bypassed; they operate on their own header/body inspection logic and will not catch this pattern.
  • Pinning Fastify to 5.12.1 or earlier — while those versions don't have *this* bug, they are affected by the separate CVE-2026-84428 (CVSS 7.5), which is a more severe header normalisation bypass in the dependencies keyword. You must go to 5.12.6+ to be clean of both.
04 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNone observed. Not listed on CISA KEV. No campaigns or threat actor mentions in open-source reporting as of 2026-10-14.
Proof of conceptNo public PoC. Not indexed on pocindex.io, no dedicated GitHub repos (e.g., CVE-2026-107832), no ExploitDB or Nuclei templates. The advisory includes a conceptual description only.
EPSSNot yet scored — CVE was published 2026-10-13; FIRST EPSS feed has not ingested it. Expected to land in the bottom quartile given AC:H and no PoC.
CVSS vectorCVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N — network-reachable but high complexity, low integrity impact only, no C or A. Scope unchanged.
Affected versionsFastify >=5.12.2, <5.12.6 (4 patch releases). Older major/minor branches (v4.x, v3.x) are not affected — the buggy lowercasing routine was introduced in 5.12.2.
Fixed versionFastify 5.12.6 (npm). No distro backports expected — Fastify is consumed via npm.
Scanning / exposureNo GreyNoise, Shodan, or Censys tags for this CVE. Fastify apps are typically behind reverse proxies and not directly fingerprintable. Fastify has ~5–13 million weekly npm downloads, but only a subset runs the affected 5.12.2–5.12.5 window.
Reporter / creditsReported by uttej-badwane and kian0417. Remediation by Matteo Collina (mcollina) and Ulises Gascón (UlisesGascon), Fastify core team.
Advisory IDsGHSA-389g-gv7q-r4x8 · CNA: OpenJS Foundation Security Advisories
Disclosure timelineReserved 2026-10-08 → Published 2026-10-13 → Fix shipped same day in 5.12.6

Sources.

  1. GHSA-389g-gv7q-r4x8 — GitHub Security Advisory
  2. CVE-2026-107832 — ThreatInt CVE Database
  3. CVE-2026-107832 — Hol Security Guard
  4. CVE-2026-107832 — Strix AI
  5. Fastify Releases — GitHub
  6. Fastify Validation and Serialization Docs
  7. CWE-178: Improper Handling of Case Sensitivity — MITRE
05 · The Call

Final Verdict
= UNCHANGED to LOW (3.7/10)

Why this verdict

  • AC:H is real, not padded. Exploitation requires the application to use the propertyNames subschema keyword with non-lowercase enum/const values for header validation — a double-niche JSON Schema pattern. The standard Fastify properties-based header schema is unaffected. Conservatively, <5% of Fastify deployments use this pattern.
  • Impact ceiling is Low integrity, period. The CVSS vector correctly shows C:N / I:L / A:N with Scope Unchanged. The bug lets a header through; it does not grant code execution, authentication bypass, or data disclosure on its own. Any downstream impact is application-specific and speculative.
  • No exploitation evidence or PoC. Zero KEV listing, zero in-the-wild sightings, zero public PoC code, and the CVE is one day old with no researcher weaponisation interest visible.
  • Trivial workaround neutralises the bug. Declaring header names in lowercase in the schema is a one-line config change that fully closes the gap, independent of patching.
  • Role multiplier: Fastify is a *user-space application framework*, not a canonical high-value-role component (not an IdP, hypervisor, CA, PAM, backup agent, kernel module, or network edge). In high-value deployments (e.g., an auth-decision API), the chain's terminal step still requires the handler to make security-relevant decisions based solely on propertyNames-validated headers — an architectural pattern that is itself a design smell. The worst plausible blast radius is *host-level* integrity degradation of a single route's input validation. No domain-takeover, fleet-compromise, or supply-chain-scale outcome is reachable from this bug alone. No floor override applies.

Why not higher?

The vulnerability has zero confidentiality or availability impact. The attack complexity is legitimately high — it targets a niche schema pattern that the vast majority of Fastify applications never use. Even when the pattern IS used, the smuggled header only bypasses one validation gate; any defence-in-depth (JWT, session middleware, upstream WAF) remains intact. There is no PoC, no exploitation, and Fastify is not a canonical high-value-role component whose compromise cascades to fleet or identity scope.

Why not lower?

The bug IS real and does affect request integrity for applications relying on propertyNames-based header validation. It is network-reachable and requires no authentication or user interaction, which means an attacker who identifies a vulnerable endpoint can exploit it silently. Declaring it IGNORE would undercount the risk for the small population of apps using this pattern in a security-relevant way.

06 · Verification

Crowdsourced verification payload.

Run this on any host where the Fastify application is deployed, or in your CI pipeline against the project's node_modules. Requires read access to node_modules/fastify/package.json. Example: bash check_cve_2026_107832.sh /app where /app is the project root. No elevated privileges needed.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# check_cve_2026_107832.sh — detect CVE-2026-107832 in fastify
# Usage: bash check_cve_2026_107832.sh [PROJECT_ROOT]
# Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN

set -euo pipefail

PROJECT_ROOT="${1:-.}"
PKG="${PROJECT_ROOT}/node_modules/fastify/package.json"

if [ ! -f "$PKG" ]; then
  echo "UNKNOWN — fastify not found in ${PROJECT_ROOT}/node_modules"
  exit 2
fi

VERSION=$(grep '"version"' "$PKG" | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')

if [ -z "$VERSION" ]; then
  echo "UNKNOWN — could not parse version from $PKG"
  exit 2
fi

echo "Detected fastify version: $VERSION"

# Parse semver components
MAJOR=$(echo "$VERSION" | cut -d. -f1)
MINOR=$(echo "$VERSION" | cut -d. -f2)
PATCH=$(echo "$VERSION" | cut -d. -f3 | cut -d- -f1)

# Affected: >=5.12.2 and <5.12.6
if [ "$MAJOR" -eq 5 ] && [ "$MINOR" -eq 12 ] && [ "$PATCH" -ge 2 ] && [ "$PATCH" -lt 6 ]; then
  echo "VULNERABLE — fastify $VERSION is affected by CVE-2026-107832"
  echo "  Upgrade to 5.12.6+: npm install [email protected]"
  echo "  Workaround: lowercase all enum/const values in propertyNames header schemas"
  exit 1
else
  echo "PATCHED — fastify $VERSION is not in the affected range (5.12.2–5.12.5)"
  exit 0
fi