/

CVE-2026-39852

Severity:

HIGH RISK

(8.2)

Authorization Bypass / Access Control Misconfiguration

CVE-2026-39852

Modified

Vulnerability type

Category:

Authorization Bypass / Access Control Misconfiguration

CWE:

CWE-863, CWE-551

Impact:

Unauthorized Access to Protected Endpoints

Severity:

HIGH RISK

(8.2)

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

A path normalization inconsistency between Quarkus's security layer and RESTEasy Reactive's routing layer allows HTTP path-based authorization checks to be bypassed using matrix parameters.

By appending a semicolon and arbitrary text to protected paths (for example, /api/admin;anything), an unauthenticated or low-privileged user may reach endpoints that are expected to be restricted.

Affected context

This vulnerability affects Quarkus applications that:

  • Use RESTEasy Reactive for HTTP routing, and
  • Rely on path-based authorization rules (e.g., securing /api/admin), and
  • Have security filters or policies that make decisions based on the raw request path, including matrix parameters.

In these setups, the security layer and routing layer interpret URLs differently: security checks are performed on the raw path with matrix parameters intact, while routing removes them before endpoint matching.

Exploit preconditions

  • Attack surface: Public or internal HTTP endpoints exposed by a Quarkus application using RESTEasy Reactive.
  • Required access: Network access to the affected endpoint; no valid credentials are required if the endpoint is assumed to be protected solely by path-based authorization.
  • Trigger point: Sending crafted HTTP requests to protected paths with an appended semicolon and arbitrary suffix (matrix parameters), such as /api/admin;anything.
  • Why exploitation is possible: The security layer authorizes based on the unnormalized, raw URL path that includes matrix parameters, while the routing layer strips these parameters and still dispatches the request to the original protected route, causing a mismatch between what was authorized and what is actually executed.

Why this happens

The core issue is an inconsistent interpretation of request paths between the security and routing layers.

Quarkus's security layer evaluates authorization rules using the raw path, which keeps matrix parameters (segments after ;) as part of the string.

RESTEasy Reactive, however, normalizes the path for routing by dropping matrix parameters before matching endpoints.

This discrepancy maps to CWE-863: Incorrect Authorization, where authorization decisions are made on data that does not accurately represent the resource ultimately accessed.

In abstract terms, this is a broken access control pattern where security policies and actual routing do not share a common, normalized representation of the target resource.

Potential impact

  • Unauthenticated users may access endpoints that are intended to require authentication.
  • Low-privileged users may invoke administrative or sensitive operations protected only by path-based rules.
  • Exposure of sensitive data normally restricted to administrators or specific roles.
  • Ability to perform state-changing actions (configuration changes, account management, data modification) through misprotected endpoints.
  • Increased risk of lateral movement within an application or broader system environment by chaining unauthorized operations.

General mitigation guidance

Effective mitigation focuses on aligning security decisions with the same normalized path used for routing and reducing reliance on raw-path authorization:

  • Normalize request paths (including removing or canonicalizing matrix parameters) before applying authorization logic so that security checks and routing act on the same representation.
  • Prefer annotation-based or method-level authorization bound directly to handlers/controllers rather than string-based path filters that inspect raw URLs.
  • Avoid treating matrix parameters, query parameters, or other path decorations as part of the security boundary when defining access rules.
  • Implement a centralized request normalization layer that runs before any security or routing decisions and is consistently used across the stack.
  • Apply least-privilege design: validate roles and permissions at the business logic level in addition to any path-based rules.
  • For reverse proxies or API gateways in front of Quarkus, ensure they also normalize paths consistently and do not reintroduce conflicting interpretations.

How teams detect issues like this

Detection requires identifying mismatches between routing and authorization logic:

  • Static analysis / code scanning:
  • Flag security filters, handlers, or interceptors that perform authorization decisions based on raw path strings (e.g., inspecting HttpServletRequest.getRequestURI() or equivalent) without explicit normalization.
  • Detect custom path-based access control logic that does not share the same path-processing utilities as the routing layer.
  • Identify usage patterns where matrix parameters (;) are not accounted for in authorization code.
  • Configuration and policy review:
  • Review security configuration (e.g., path patterns in security policies) to ensure they correspond exactly to the normalized routes defined in RESTEasy Reactive.
  • Check for assumptions that path segments are immutable and free of matrix parameters.
  • Dynamic testing:
  • Incorporate tests that send requests to protected endpoints with appended matrix parameters (e.g., /admin;test) to confirm that access is denied as expected.
  • Use automated API security testing tools or fuzzers configured to mutate paths with semicolons and other normalization edge cases.
  • Logging and monitoring:
  • Log normalized paths and raw request paths for sensitive endpoints and compare them to detect unusual patterns (e.g., frequent use of semicolons on protected routes).
  • Alert on access to critical routes where the raw and normalized path differ significantly.

Sources

SourceLink
github.comgithub.com/quarkusio/quarkus/security/advisories/GHSA-rc95-pcm8-65v9
access.redhat.comaccess.redhat.com/errata/RHSA-2026:11720
access.redhat.comaccess.redhat.com/errata/RHSA-2026:11721
access.redhat.comaccess.redhat.com/errata/RHSA-2026:13631
access.redhat.comaccess.redhat.com/errata/RHSA-2026:17789
access.redhat.comaccess.redhat.com/errata/RHSA-2026:25089
access.redhat.comaccess.redhat.com/errata/RHSA-2026:34608
access.redhat.comaccess.redhat.com/errata/RHSA-2026:54435
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-39852
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2457819
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-39852.json

Frequently asked

questions

Exploitability depends on how heavily an application relies on path-based authorization.

Any exposed endpoint protected primarily by path patterns and served through RESTEasy Reactive may be susceptible if path normalization and authorization are not aligned.

An attacker only needs network-level access to the affected HTTP endpoints.

In many cases, no authentication is required if the endpoint trusts path-based security to block unauthenticated users.

The safest approach is to ensure authorization decisions are made after the request path has been canonicalized in the same way as the routing layer, and to move critical access control logic as close as possible to the endpoint implementation (e.g., method-level authorization annotations or filters tied to normalized routes).

Use a single, shared path normalization routine for both routing and security, avoid ad-hoc string comparisons against raw URLs, and favor role and permission checks at the handler/business logic level over purely path-based rules.

Incorporating automated tests and tooling that exercise path normalization edge cases (semicolons, encodings, redundant segments) can help catch such discrepancies early in development.

Find out what's already
exploitable in your codebase.