/

CVE-2026-54761

Severity:

HIGH RISK

(7.1)

AuthZ Bypass (CWE-284) in Traefik Kubernetes Gateway

CVE-2026-54761

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-284, CWE-863

Impact:

Exposure of Internal Management Services

Severity:

HIGH RISK

(7.1)

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 misapplied authorization check in Traefik's Kubernetes Gateway provider lets HTTPRoutes from non-allow-listed namespaces access internal Traefik services via crafted backend references.

When an attacker can create HTTPRoute and ReferenceGrant resources in or near allow-listed namespaces, they may expose internal APIs such as api@internal, dashboard@internal, or rest@internal on the data plane.

Affected context

This issue appears in Traefik deployments using the Kubernetes Gateway provider with crossProviderNamespaces allowlists configured.

It specifically affects HTTPRoute resources that define multiple backendRefs with weighted round-robin (WRR) rules.

The vulnerability manifests when internal Traefik services (e.g., api@internal, dashboard@internal, rest@internal) are reachable via cross-provider references and ReferenceGrants exist from allow-listed namespaces.

Exploit preconditions

  • Attack surface: Kubernetes Gateway API (HTTPRoute and ReferenceGrant resources)
  • Required access: Ability to create an accepted HTTPRoute in a non-allow-listed namespace and a matching ReferenceGrant in an allow-listed namespace (or influence those namespaces)
  • Trigger point: Evaluation of backendRefs for WRR HTTPRoute rules where backendRef.namespace points to an allow-listed namespace
  • Why exploitation is possible: The crossProviderNamespaces allowlist is enforced against the backendRef.namespace instead of the HTTPRoute's namespace, allowing routes from non-allow-listed namespaces to piggyback on allow-listed namespaces and reach internal Traefik services.

Why this happens

The underlying bug is an authorization logic error where access control is evaluated against the wrong security principal.

Instead of tying the crossProviderNamespaces allowlist to the originating HTTPRoute namespace, Traefik evaluates it against the target backendRef.namespace for WRR rules.

This aligns with CWE-284: Improper Access Control and CWE-863: Incorrect Authorization, where policy enforcement is applied to an incorrect context, resulting in unintended access to internal management endpoints.

Potential impact

  • Internal Traefik APIs (api@internal) may be exposed to untrusted client traffic on the data plane.
  • Administrative dashboards (dashboard@internal) could become reachable from namespaces that were not meant to access them.
  • REST management endpoints (rest@internal) can be queried from routes originating in non-allow-listed namespaces.
  • Configuration and operational data about the reverse proxy may be disclosed or altered via exposed internal services.
  • Attackers could chain this exposure with other weaknesses to escalate privileges or pivot within the cluster's control plane.

General mitigation guidance

Mitigation centers on enforcing access control based on the correct origin context and reducing the blast radius of cross-namespace references.

Useful defensive patterns include:

  • Ensure authorization decisions for cross-provider services are bound to the requesting resource's namespace or identity, not just the target's namespace.
  • Design Gateway and reverse proxy configurations so that internal management services are isolated on separate planes (e.g., admin vs. data), with distinct policies and listeners.
  • Restrict use of ReferenceGrant and cross-namespace backendRefs to tightly controlled, audited namespaces to minimize unintended exposure.
  • Apply least-privilege principles to internal management endpoints, disabling or limiting those not required in production, and avoid exposing them via generic routing constructs.
  • Consider policy admission controls (e.g., Kubernetes admission webhooks or policy engines) to prevent unsafe cross-namespace HTTPRoute and ReferenceGrant combinations.

How teams detect issues like this

Detection typically focuses on configuration and policy analysis around Gateway API resources:

  • Use static configuration review or policy-as-code (e.g., OPA/Gatekeeper, Kyverno) to flag HTTPRoutes that reference internal Traefik services via backendRefs from non-allow-listed namespaces.
  • Inspect ReferenceGrant resources for patterns that permit cross-namespace access to internal Traefik services and ensure they align with explicit administrative policies.
  • During code and infrastructure-as-code reviews, look for WRR backendRef configurations where namespace values differ from the HTTPRoute's namespace in ways that circumvent intended allowlists.
  • Employ automated cluster configuration scanners to monitor for unexpected exposure of management endpoints on data plane ingress routes and alert on violations of defined network segmentation rules.

Sources

SourceLink
github.comgithub.com/traefik/traefik/releases/tag/v3.6.21
github.comgithub.com/traefik/traefik/releases/tag/v3.7.5
github.comgithub.com/traefik/traefik/security/advisories/GHSA-3g6v-2r68-prfc

Frequently asked

questions

Yes, if an attacker can create or influence HTTPRoute and ReferenceGrant resources, they can remotely reach internal Traefik services via standard HTTP traffic flowing through the data plane.

The attacker needs Kubernetes API-level permissions to create an accepted HTTPRoute and a compatible ReferenceGrant from an allow-listed namespace or coordinate with an entity that has such access. No changes to Traefik's static configuration or RBAC inside Traefik itself are required.

The safest pattern is to ensure that authorization checks for cross-provider and cross-namespace references are based on the originating route's namespace or identity and to strictly segregate internal management endpoints from data plane routing, enforcing least-privilege policies for crossNamespace references.

Future prevention relies on designing access control with clear trust boundaries, validating them through policy-as-code (e.g., admission controllers), and regularly reviewing Gateway API and reverse proxy configurations for misaligned authorization logic, particularly where cross-namespace or cross-provider references are involved.

Find out what's already
exploitable in your codebase.