Severity:

HIGH RISK

(7.5)

Improper Input Handling / URI Normalization in Vert.x Web

CVE-2026-1002

Analyzed

Vulnerability type

Category:

Improper Input Handling / URI Normalization

CWE:

CWE-444

Impact:

Denial of Service (targeted resource unavailability)

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Vert.x Web's static handler cache mishandles specially crafted request URIs, allowing attackers to poison the cache and deny access to otherwise valid static files.

By exploiting an improper implementation of URI normalization rules, an attacker can cause legitimate resources to return HTTP 404, resulting in a targeted denial of service for cached static content.

Affected context

This vulnerability affects applications using Vert.x Web's Static Handler with caching enabled to serve static assets such as HTML, JavaScript, CSS, or images.

The issue manifests when the handler relies on the Vert.x Core URI processing that does not correctly implement the C. rule of RFC 3986 section 5.2.4, causing equivalent resource paths to be treated inconsistently for caching.

Environments where static resources are heavily cached for performance and are directly exposed over HTTP/HTTPS are particularly susceptible to visible impact.

Exploit preconditions

  • Attack surface: Public or internal HTTP/HTTPS endpoints served by Vert.x Web Static Handler.
  • Required access: Ability to send arbitrary HTTP requests to the affected endpoint (no special privileges beyond network reachability).
  • Trigger point: Requests to static resources using specially crafted URIs that insert encoded path segments (e.g., bar%2F..%2F) after the last /.
  • Why exploitation is possible: The cache key and/or resource resolution logic treats these crafted URIs incorrectly due to improper URI normalization, allowing an attacker to poison or misalign cache entries so that subsequent requests to legitimate URLs yield 404 responses.

Why this happens

The root cause is an inconsistent and incomplete application of URI normalization logic in the Vert.x Core component used by Vert.x Web, specifically violating the C. rule in RFC 3986 section 5.2.4 for resolving relative path segments.

Crafted URIs that use encoded separators like %2F combined with .. segments are not normalized to the same canonical path as their straightforward counterparts.

As a result, the static handler cache can be populated or invalidated based on malformed or alternate representations of the path, aligning with CWE-444: Inconsistent Interpretation of HTTP Requests ('HTTP Request Smuggling') in the sense that different parts of the system interpret semantically equivalent URIs differently.

Abstractly, this is a failure to consistently canonicalize and validate input paths before using them as cache keys or for resource resolution.

Potential impact

  • Individual static resources may return HTTP 404 even though the files exist and are configured to be served.
  • Targeted denial of service against specific pages or assets (e.g., main index.html, JavaScript bundles, or CSS files).
  • Degradation of user experience, including broken pages or missing resources.
  • Increased operational overhead as operators investigate seemingly random 404s for valid files.
  • Potential amplification of impact when combined with other caching or routing layers that rely on consistent URI handling.

General mitigation guidance

Mitigation should focus on ensuring consistent URI normalization and reducing trust in raw request paths for cache decisions.

Common defensive patterns include:

  • Avoid relying on non-canonical request URIs as cache keys; normalize and validate paths before caching or resource lookup.
  • Enforce strict path validation, rejecting or redirecting requests that contain ambiguous encodings or mixed encoded path separators.
  • Configure static resource handling to treat equivalent URIs identically and to avoid separate cache entries for alternate encodings.
  • Limit or disable caching in components that perform complex path resolution, especially when full normalization guarantees are not present.
  • Apply least-privilege to routing rules so that static handlers only serve from well-defined, constrained directories with tightly controlled path transformations.

How teams detect issues like this

Detection can combine runtime observation with code and configuration review:

  • Static analysis / code review:
  • Identify usages of Vert.x Web StaticHandler where .setCachingEnabled(true) (default or explicit) is used with unvalidated URIs.
  • Look for custom routing or pre-processing logic that manipulates request paths prior to static handler invocation without clear normalization.
  • Runtime monitoring:
  • Monitor access logs for repeated requests including encoded separators and .. segments (e.g., %2F..%2F) targeting static resources.
  • Correlate spikes in 404 responses for known-good static files with unusual URI patterns.
  • Security testing:
  • Incorporate fuzzing of path components with mixed encoded and plain separators and traversal segments into API and web application test suites.
  • Use automated scanners or custom scripts to probe for cache poisoning behavior by alternating between canonical and crafted URIs.
  • Policy enforcement:
  • Enforce gateway or WAF rules that normalize or block ambiguous path encodings before they reach backend Vert.x services.

Sources

SourceLink
github.comgithub.com/eclipse-vertx/vert.x/pull/5895
github.comgithub.com/vert-x3/vertx-web/issues/2836

Frequently asked

questions

Yes. Any attacker who can send HTTP requests to the affected Vert.x Web endpoint can attempt to exploit the bug by crafting specific URIs, without needing authentication in most typical public-facing setups.

No special credentials are inherently required. The primary requirement is network access to the service using the static handler with caching enabled. However, the actual access control posture depends on how the application and network perimeter are configured.

The most robust fix pattern is to ensure correct URI normalization before cache usage and resource resolution, aligning with RFC 3986. In practice, this means using a canonical path representation as the basis for cache keys and rejecting or sanitizing ambiguous URIs. As an immediate risk-reduction measure, disabling caching for the static handler removes the vulnerable behavior surface.

Prevent similar flaws by standardizing on well-tested URI parsing and normalization routines, avoiding ad hoc path manipulation, and enforcing canonicalization before any security-sensitive decisions like caching, routing, or authorization. Complement this with input validation, defensive configuration defaults, and automated tests that cover edge-case encodings and path traversal patterns.

Find out what's already
exploitable in your codebase.