/

CVE-2026-65602

Severity:

HIGH RISK

(8.8)

Authorization Bypass (CWE-863) in Traefik TCP Routes

CVE-2026-65602

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Unauthorized Cross-Provider Resource Access

Severity:

HIGH RISK

(8.8)

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

Traefik does not consistently enforce the crossProviderNamespaces allowlist for serversTransport references used by IngressRouteTCP services. A low-privileged Kubernetes user may therefore reference a forbidden file-provider transport and cause TCP traffic to use privileged settings such as backend mTLS credentials, SPIFFE identity, or PROXY-protocol behavior.

Affected context

The issue affects Traefik Kubernetes deployments that:

  • Use IngressRouteTCP resources
  • Permit namespace users to create or modify TCP routing resources
  • Configure serversTransport references across Traefik providers
  • Rely on crossProviderNamespaces to restrict access to provider-owned resources

The authorization gap occurs when TCP route processing fails to apply the same cross-provider namespace restrictions enforced for HTTP routes.

Exploit preconditions

  • Attack surface: Kubernetes custom resources processed by Traefik
  • Required access: Low-privileged permission to create or modify an IngressRouteTCP in a namespace outside the configured allowlist
  • Trigger point: Resolution of a TCP service's serversTransport reference
  • Why exploitation is possible: The TCP reference path does not consistently enforce the configured cross-provider namespace authorization boundary, allowing a forbidden file-provider transport to be selected

Why this happens

The underlying bug is an authorization enforcement inconsistency between HTTP and TCP routing paths. The crossProviderNamespaces policy is applied to HTTP serversTransport references but omitted or insufficiently applied when resolving references from IngressRouteTCP services.

This maps to CWE-863: Incorrect Authorization, because a principal with limited namespace-level permissions can access a cross-provider resource that should be restricted by policy. The insecure pattern is enforcing an authorization rule in one resource-processing path while leaving an equivalent path unchecked.

Potential impact

  • Unauthorized use of privileged backend transport settings
  • Exposure or use of backend mTLS client certificates
  • Impersonation of configured SPIFFE identities
  • Unexpected PROXY-protocol behavior affecting backend trust decisions
  • Circumvention of namespace-based administrative boundaries
  • Potential access to protected services or sensitive backend data

General mitigation guidance

Mitigation generally focuses on consistent authorization enforcement across every resource type and provider-reference path.

Common defensive patterns include:

  • Applying the same namespace and provider allowlist checks to HTTP, TCP, and other routing resources
  • Rejecting unresolved or unauthorized cross-provider references by default
  • Restricting which Kubernetes users and service accounts can create or modify IngressRouteTCP resources
  • Separating privileged transport configurations from namespaces controlled by lower-trust users
  • Avoiding unnecessary client certificates, SPIFFE identities, and proxy settings in shared or broadly accessible configurations
  • Running Traefik and backend integrations with least privilege
  • Treating provider references as security-sensitive inputs rather than ordinary configuration values

How teams detect issues like this

Organizations can look for this issue through:

  • Static and configuration analysis that compares authorization checks across HTTP and TCP reference-resolution paths
  • Code review signals where one route type validates crossProviderNamespaces but another uses a shared lookup without equivalent authorization
  • Kubernetes audit logs showing low-privileged users creating or modifying IngressRouteTCP resources with cross-provider serversTransport references
  • Policy rules that restrict cross-provider references and privileged transport settings by namespace
  • Runtime monitoring for unexpected use of file-provider transports, client certificates, SPIFFE identities, or PROXY-protocol options

Automated security review tools may help identify inconsistent authorization branches and unrestricted provider-resource lookups.

Sources

SourceLink
github.comgithub.com/traefik/traefik/commit/26c96a3935cafb473f4a5bae1886560d9aa4e4f0
github.comgithub.com/traefik/traefik/security/advisories/GHSA-42cj-m3vj-89wv
vulncheck.comvulncheck.com/advisories/traefik-before-ingressroutetcp-serverstransport-namespace-bypass

Frequently asked

questions

It can be exploitable through the Kubernetes control plane when a user has permission to create or modify IngressRouteTCP resources. It does not generally require direct network access to the Traefik process.

The attacker typically needs low-privileged, namespace-scoped Kubernetes access sufficient to submit or change an IngressRouteTCP. Access to the protected file-provider configuration is not necessarily required.

Enforce crossProviderNamespaces and equivalent authorization checks consistently for every route type and provider-reference resolution path, with unauthorized references rejected by default.

Use deny-by-default namespace policies, limit route-resource permissions, review privileged transport settings, and test authorization boundaries across all supported protocol-specific resource types.

Find out what's already
exploitable in your codebase.