/

CVE-2026-54765

Severity:

HIGH RISK

(8.5)

Authorization Filter Confusion (CWE-863) in Traefik Gateway

CVE-2026-54765

Analyzed

Vulnerability type

Category:

Authorization Bypass via Misrouting

CWE:

CWE-284, CWE-863

Impact:

Privilege Escalation and Cross-Tenant Access

Severity:

HIGH RISK

(8.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

A routing logic flaw in Traefik's Kubernetes Gateway API provider can cause security-sensitive backendRef filters from one HTTPRoute to be applied to requests intended for another route targeting the same Service:port.

In multi-tenant or cross-namespace deployments that rely on header-based identity or authorization context, an attacker who can create an accepted HTTPRoute to the same backend may cause their filter context to be reused, leading to privilege or tenant boundary violations.

Affected context

This vulnerability occurs in Traefik deployments using the Kubernetes Gateway API provider where:

  • Multiple HTTPRoutes are accepted that target the same backend Service and port
  • backendRef filters are used to set or manipulate security-relevant headers (e.g., tenant ID, auth context)
  • ReferenceGrant objects may allow cross-namespace targeting of Services

Under these conditions, Traefik may treat distinct HTTPRoutes as sharing a single child service and apply only one route's filter set to all requests reaching that backend, affecting isolation expectations.

Exploit preconditions

  • Attack surface: Kubernetes Gateway API configuration, specifically HTTPRoute resources.
  • Required access: Ability to create or modify an accepted HTTPRoute that targets the same backend Service:port as a victim route, possibly within a different namespace when permitted by ReferenceGrant.
  • Trigger point: Traefik's resolution of multiple HTTPRoutes to a shared child service where backendRef filters are merged incorrectly, leading to one filter set being reused across routes.
  • Why exploitation is possible: The routing implementation does not maintain filter isolation per HTTPRoute when they converge on the same backend Service:port, allowing an attacker-controlled route's filter context to be applied to other traffic.

Why this happens

The underlying bug class maps to CWE-863: Incorrect Authorization, combined with CWE-284: Improper Access Control.

Traefik's Gateway API provider incorrectly models per-route filter state when multiple HTTPRoutes target the same backend. Instead of treating each route's backendRef filters as isolated authorization and identity configuration, the implementation conflates them at the child service level.

This insecure pattern causes authorization-related headers or trust signals set by filters to be reused across logically distinct routes, violating assumptions about tenant or namespace isolation and enabling unintended privilege propagation.

Potential impact

  • Requests from one tenant may be processed with another tenant's identity or authorization context.
  • An attacker-controlled route may cause privileged or trusted headers to be attached to other routes' traffic.
  • Cross-namespace access to protected backend resources could occur when ReferenceGrant permits shared Service targeting.
  • Backend services may incorrectly trust spoofed or misapplied security headers, leading to privilege escalation.
  • Auditing and logging based on headers may misattribute actions or hide malicious activity.

General mitigation guidance

Mitigation focuses on strengthening isolation boundaries and reducing reliance on mutable, routing-layer headers for security decisions.

Common defensive patterns include:

  • Designing Gateway and routing configurations so that security-sensitive headers (tenant ID, auth context) are derived inside the backend from authenticated tokens rather than set solely by filters.
  • Segregating high-privilege or sensitive backends behind distinct Services or ports, avoiding shared Service:port targets for mixed-tenant traffic.
  • Restricting which namespaces can define HTTPRoutes to critical Services, and minimizing cross-namespace ReferenceGrant usage for security-sensitive backends.
  • Applying least-privilege controls on routing filters, limiting which principals can configure security-relevant headers.
  • Using defense-in-depth at the backend (e.g., authorization checks based on validated identity claims, not just header presence).

How teams detect issues like this

Detection typically involves analyzing configuration and behavior rather than payloads:

  • Configuration review to identify multiple HTTPRoutes targeting the same Service:port while using backendRef filters to set identity or authorization headers.
  • Policy enforcement tools or admission controllers that flag or block HTTPRoutes which attempt to manipulate security-critical headers, particularly in multi-tenant clusters.
  • Static analysis of Gateway API manifests (GitOps repos, YAML) to detect cross-namespace ReferenceGrants combined with shared backend targets and sensitive filters.
  • Runtime monitoring of request headers at backends to spot unexpected or inconsistent identity/authorization values coming from different routes or namespaces.
  • Use of automated configuration scanning tools that can model Gateway routing and highlight potential authorization boundary violations.

Sources

SourceLink
github.comgithub.com/traefik/traefik/commit/8aada7a7d52e4588a75386d8b86d270f6fe8d549
github.comgithub.com/traefik/traefik/pull/13367
github.comgithub.com/traefik/traefik/releases/tag/v3.7.6
github.comgithub.com/traefik/traefik/security/advisories/GHSA-6p8f-p8j2-rqmv

Frequently asked

questions

It does not directly compromise Traefik itself, but it can cause authorization and tenant boundaries enforced via routing filters to fail, potentially leading to unauthorized access to backend services within the cluster.

An attacker must be able to create or modify an accepted HTTPRoute that targets the same backend Service:port as another route. In some deployments, this may be possible for regular tenants within their namespace when ReferenceGrant permits cross-namespace targeting.

Ensure that authorization, tenant identity, and other trust decisions are enforced inside backend services based on authenticated credentials rather than relying solely on headers set by Gateway filters, and design routing so sensitive backends are not shared across tenants via the same Service:port.

Adopt strict configuration policies for Gateway API resources, limit cross-namespace references to sensitive Services, use admission control to restrict security-sensitive header filters, and perform regular configuration audits to verify that routing and authorization boundaries align with multi-tenant isolation requirements.

Find out what's already
exploitable in your codebase.