/

CVE-2026-26308

Severity:

HIGH RISK

(7.5)

Authorization Bypass in Envoy RBAC Filter

CVE-2026-26308

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Bypass of RBAC Deny Rules and Unauthorized Access

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

Envoy's RBAC filter previously concatenated multiple HTTP header values into a single comma-separated string before evaluation, instead of validating each value individually.

Under this behavior, an attacker could craft duplicate headers to hide a disallowed value from exact-match Deny rules, potentially bypassing access control policies and reaching protected upstream services.

Affected context

This vulnerability manifests in Envoy deployments that:

  • Use the RBAC filter for HTTP traffic authorization decisions
  • Rely on exact-match rules against HTTP headers (e.g., specific tokens, API keys, or control flags)
  • Accept or forward requests where multiple values for the same header name may be present

In such configurations, Envoy's header handling behavior—concatenating multiple header values before evaluation—creates a gap between the policy author's expectations and the actual enforcement logic.

Exploit preconditions

  • Attack surface: HTTP interfaces fronted by Envoy where RBAC is applied (edge, API gateway, or internal service mesh).
  • Required access: Ability to send crafted HTTP requests to an Envoy listener protected by the RBAC filter.
  • Trigger point: Submission of requests containing duplicate headers (multiple instances of the same header name) that are used in RBAC match conditions.
  • Why exploitation is possible: The RBAC filter evaluates a single concatenated representation of all header values. Exact-match Deny rules may only inspect a combined string that does not exactly match the forbidden value, even though one of the individual values is malicious, enabling those requests to be erroneously allowed.

Why this happens

The core issue is a mismatch between the authorization policy model and the underlying data representation of HTTP headers.

Envoy's RBAC implementation collapses multiple header instances into one comma-separated string before applying match conditions. This design assumes that the combined representation is semantically equivalent to validating each header value independently.

In practice, many RBAC policies are written with the mental model that each header value is evaluated separately. When Deny rules rely on exact matches, concatenation can obscure an otherwise disallowed value, resulting in CWE-863: Incorrect Authorization—the system fails to enforce the intended access control semantics because of flawed logic in policy evaluation.

Potential impact

  • Requests containing header values that should be explicitly denied may be allowed through.
  • Attackers could gain unauthorized access to APIs or microservices that rely on Envoy RBAC for protection.
  • Security controls based on specific header markers (e.g., environment flags, internal-only tags, or tenant identifiers) could be bypassed.
  • Defense-in-depth assumptions may be weakened if upstream services trust Envoy's RBAC enforcement boundary.

General mitigation guidance

Effective mitigation typically focuses on aligning authorization logic with the actual structure of HTTP headers and hardening policy design:

  • Prefer authorization mechanisms that validate each header value atomically rather than against a concatenated string representation.
  • Design RBAC policies to tolerate header ambiguity by using more robust patterns (e.g., presence/absence checks, prefix/suffix/regex matches) instead of relying solely on exact full-string equality for multi-valued headers.
  • Normalize request headers before policy evaluation, such as rejecting requests with unexpected duplicate headers in sensitive fields or enforcing a single-valued invariant at the edge.
  • Apply the principle of least privilege in upstream services so that they do not solely trust Envoy for authorization; services should perform their own context checks where feasible.
  • Document and standardize which headers are security-sensitive and ensure clients are not allowed to arbitrarily control those headers across trust boundaries.

How teams detect issues like this

Detection efforts can focus on both code and configuration behaviors:

  • Policy review: Examine RBAC configurations for Deny rules that depend on exact string matches for headers likely to appear multiple times (e.g., X-Forwarded-*, Cookie, custom multi-valued headers).
  • Static analysis / configuration scanning: Use tooling to parse Envoy configs and flag RBAC policies where header-based conditions are exact-match and potentially susceptible to concatenation ambiguity.
  • Traffic analysis: Inspect access logs and authorization audit logs for patterns where requests with duplicate headers are unexpectedly allowed, especially around security-critical endpoints.
  • Testing and fuzzing: Incorporate negative tests that send duplicate headers for protected endpoints to verify that Deny rules still trigger as intended.
  • Automated policy-as-code frameworks and CI checks can be employed to enforce guidelines such as "reject duplicate values for security-sensitive headers" or "disallow exact-match Deny rules on multi-valued headers".

Sources

SourceLink
github.comgithub.com/envoyproxy/envoy/commit/b6ba0b2294b98484fb0ed8556897d1073cc27867
github.comgithub.com/envoyproxy/envoy/security/advisories/GHSA-ghc4-35x6-crw5

Frequently asked

questions

Yes. Any remote client capable of sending HTTP requests to an Envoy-protected endpoint can potentially exploit this issue by crafting requests with duplicate headers that target RBAC header checks.

The attacker only needs network access to an Envoy listener using the RBAC filter. No prior authentication is required if the RBAC policy is the primary access control mechanism for that endpoint.

The safest approach is to ensure that authorization decisions operate on the actual set of header values, not a lossy concatenated representation. Policies should be evaluated per header value or requests with unexpected duplicate security-sensitive headers should be rejected outright, aligning the implementation with the policy author's intent.

Prevent recurrence by clearly defining how headers are normalized before authorization, documenting this model for policy authors, and enforcing it through configuration linting and automated tests. When designing RBAC rules, assume hostile input, explicitly handle multi-valued headers, and treat any ambiguity in request structure as a reason to deny or further scrutinize the request.

Find out what's already
exploitable in your codebase.