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".

