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.

