1030 lines
27 KiB
Go
1030 lines
27 KiB
Go
package tcp
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/tls"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/traefik/traefik/v3/pkg/config/dynamic"
|
|
"github.com/traefik/traefik/v3/pkg/config/runtime"
|
|
tcpmiddleware "github.com/traefik/traefik/v3/pkg/server/middleware/tcp"
|
|
"github.com/traefik/traefik/v3/pkg/server/service/tcp"
|
|
tcp2 "github.com/traefik/traefik/v3/pkg/tcp"
|
|
traefiktls "github.com/traefik/traefik/v3/pkg/tls"
|
|
)
|
|
|
|
type applyRouter func(conf *runtime.Configuration)
|
|
|
|
type checkRouter func(addr string, timeout time.Duration) error
|
|
|
|
type httpForwarder struct {
|
|
net.Listener
|
|
connChan chan net.Conn
|
|
errChan chan error
|
|
}
|
|
|
|
func newHTTPForwarder(ln net.Listener) *httpForwarder {
|
|
return &httpForwarder{
|
|
Listener: ln,
|
|
connChan: make(chan net.Conn),
|
|
errChan: make(chan error),
|
|
}
|
|
}
|
|
|
|
// Close closes the Listener.
|
|
func (h *httpForwarder) Close() error {
|
|
h.errChan <- http.ErrServerClosed
|
|
|
|
return nil
|
|
}
|
|
|
|
// ServeTCP uses the connection to serve it later in "Accept".
|
|
func (h *httpForwarder) ServeTCP(conn tcp2.WriteCloser) {
|
|
h.connChan <- conn
|
|
}
|
|
|
|
// Accept retrieves a served connection in ServeTCP.
|
|
func (h *httpForwarder) Accept() (net.Conn, error) {
|
|
select {
|
|
case conn := <-h.connChan:
|
|
return conn, nil
|
|
case err := <-h.errChan:
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Test_Routing aims to settle the behavior between routers of different types on the same TCP entryPoint.
|
|
// It has been introduced as a regression test following a fix on the v2.7 TCP Muxer.
|
|
//
|
|
// The routing precedence is roughly as follows:
|
|
// - TCP over HTTP
|
|
// - HTTPS over TCP-TLS
|
|
//
|
|
// Discrepancies for server sending first bytes support:
|
|
// - On v2.6, it is possible as long as you have one and only one TCP Non-TLS HostSNI(`*`) router (so called CatchAllNoTLS) defined.
|
|
// - On v2.7, it is possible as long as you have zero TLS/HTTPS router defined.
|
|
//
|
|
// Discrepancies in routing precedence between TCP and HTTP routers:
|
|
// - TCP HostSNI(`*`) and HTTP Host(`foobar`)
|
|
// - On v2.6 and v2.7, the TCP one takes precedence.
|
|
//
|
|
// - TCP ClientIP(`[::]`) and HTTP Host(`foobar`)
|
|
// - On v2.6, ClientIP matcher doesn't exist.
|
|
// - On v2.7, the TCP one takes precedence.
|
|
//
|
|
// Routing precedence between TCP-TLS and HTTPS routers (considering a request/connection with the servername "foobar"):
|
|
// - TCP-TLS HostSNI(`*`) and HTTPS Host(`foobar`)
|
|
// - On v2.6 and v2.7, the HTTPS one takes precedence.
|
|
//
|
|
// - TCP-TLS HostSNI(`foobar`) and HTTPS Host(`foobar`)
|
|
// - On v2.6 and v2.7, the HTTPS one takes precedence (overriding the TCP-TLS one in v2.6).
|
|
//
|
|
// - TCP-TLS HostSNI(`*`) and HTTPS PathPrefix(`/`)
|
|
// - On v2.6 and v2.7, the HTTPS one takes precedence (overriding the TCP-TLS one in v2.6).
|
|
//
|
|
// - TCP-TLS HostSNI(`foobar`) and HTTPS PathPrefix(`/`)
|
|
// - On v2.6 and v2.7, the TCP-TLS one takes precedence.
|
|
func Test_Routing(t *testing.T) {
|
|
// This listener simulates the backend service.
|
|
// It is capable of switching into server first communication mode,
|
|
// if the client takes to long to send the first bytes.
|
|
tcpBackendListener, err := net.Listen("tcp", "127.0.0.1:0")
|
|
require.NoError(t, err)
|
|
// This allows the closing of the TCP backend listener to happen last.
|
|
t.Cleanup(func() {
|
|
tcpBackendListener.Close()
|
|
})
|
|
|
|
go func() {
|
|
for {
|
|
conn, err := tcpBackendListener.Accept()
|
|
if err != nil {
|
|
var opErr *net.OpError
|
|
if errors.As(err, &opErr) && opErr.Temporary() {
|
|
continue
|
|
}
|
|
|
|
var urlErr *url.Error
|
|
if errors.As(err, &urlErr) && urlErr.Temporary() {
|
|
continue
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
err = conn.SetReadDeadline(time.Now().Add(200 * time.Millisecond))
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
buf := make([]byte, 100)
|
|
_, err = conn.Read(buf)
|
|
|
|
var opErr *net.OpError
|
|
if err == nil {
|
|
_, err = fmt.Fprint(conn, "TCP-CLIENT-FIRST")
|
|
require.NoError(t, err)
|
|
} else if errors.As(err, &opErr) && opErr.Timeout() {
|
|
_, err = fmt.Fprint(conn, "TCP-SERVER-FIRST")
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
err = conn.Close()
|
|
require.NoError(t, err)
|
|
}
|
|
}()
|
|
|
|
// Configuration defining the TCP backend service, used by TCP routers later.
|
|
conf := &runtime.Configuration{
|
|
TCPServices: map[string]*runtime.TCPServiceInfo{
|
|
"tcp": {
|
|
TCPService: &dynamic.TCPService{
|
|
LoadBalancer: &dynamic.TCPServersLoadBalancer{
|
|
Servers: []dynamic.TCPServer{
|
|
{
|
|
Address: tcpBackendListener.Addr().String(),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
dialerManager := tcp2.NewDialerManager(nil)
|
|
dialerManager.Update(map[string]*dynamic.TCPServersTransport{"default@internal": {}})
|
|
serviceManager := tcp.NewManager(conf, dialerManager)
|
|
|
|
// Creates the tlsManager and defines the TLS 1.0 and 1.2 TLSOptions.
|
|
tlsManager := traefiktls.NewManager()
|
|
tlsManager.UpdateConfigs(
|
|
context.Background(),
|
|
map[string]traefiktls.Store{},
|
|
map[string]traefiktls.Options{
|
|
"default": {
|
|
MinVersion: "VersionTLS10",
|
|
MaxVersion: "VersionTLS10",
|
|
},
|
|
"tls10": {
|
|
MinVersion: "VersionTLS10",
|
|
MaxVersion: "VersionTLS10",
|
|
},
|
|
"tls12": {
|
|
MinVersion: "VersionTLS12",
|
|
MaxVersion: "VersionTLS12",
|
|
},
|
|
},
|
|
[]*traefiktls.CertAndStores{})
|
|
|
|
middlewaresBuilder := tcpmiddleware.NewBuilder(conf.TCPMiddlewares)
|
|
|
|
manager := NewManager(conf, serviceManager, middlewaresBuilder,
|
|
nil, nil, tlsManager)
|
|
|
|
type checkCase struct {
|
|
checkRouter
|
|
|
|
desc string
|
|
expectedError string
|
|
timeout time.Duration
|
|
}
|
|
|
|
testCases := []struct {
|
|
desc string
|
|
routers []applyRouter
|
|
checks []checkCase
|
|
}{
|
|
{
|
|
desc: "No routers",
|
|
routers: []applyRouter{},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP with client sending first bytes should fail",
|
|
checkRouter: checkTCPClientFirst,
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "TCP with server sending first bytes should fail",
|
|
checkRouter: checkTCPServerFirst,
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "HTTP request should be handled by HTTP service (404)",
|
|
checkRouter: checkHTTP,
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should fail",
|
|
checkRouter: checkTCPTLS12,
|
|
// The HTTPS forwarder catches the connection with the TLS 1.0 config,
|
|
// because no matching routes are defined with the custom TLS Config.
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should be handled by HTTPS (HTTPS forwarder with tls 1.0 config) (404)",
|
|
checkRouter: checkHTTPSTLS10,
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should fail",
|
|
checkRouter: checkHTTPSTLS12,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "Single TCP CatchAll router",
|
|
routers: []applyRouter{routerTCPCatchAll},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP with client sending first bytes should be handled by TCP service",
|
|
checkRouter: checkTCPClientFirst,
|
|
},
|
|
{
|
|
desc: "TCP with server sending first bytes should be handled by TCP service",
|
|
checkRouter: checkTCPServerFirst,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "Single HTTP router",
|
|
routers: []applyRouter{routerHTTP},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "HTTP request should be handled by HTTP service",
|
|
checkRouter: checkHTTP,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "Single TCP TLS router",
|
|
routers: []applyRouter{routerTCPTLS},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should be handled by TCP service",
|
|
checkRouter: checkTCPTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "Single TCP TLS CatchAll router",
|
|
routers: []applyRouter{routerTCPTLSCatchAll},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should be handled by TCP service",
|
|
checkRouter: checkTCPTLS10,
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should fail",
|
|
checkRouter: checkTCPTLS12,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "Single HTTPS router",
|
|
routers: []applyRouter{routerHTTPS},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should fail",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "Single HTTPS PathPrefix router",
|
|
routers: []applyRouter{routerHTTPSPathPrefix},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS10,
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should fail",
|
|
checkRouter: checkHTTPSTLS12,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "TCP CatchAll router && HTTP router",
|
|
routers: []applyRouter{routerTCPCatchAll, routerHTTP},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP client sending first bytes should be handled by TCP service",
|
|
checkRouter: checkTCPClientFirst,
|
|
},
|
|
{
|
|
desc: "TCP server sending first bytes should be handled by TCP service",
|
|
checkRouter: checkTCPServerFirst,
|
|
},
|
|
{
|
|
desc: "HTTP request should fail, because handled by TCP service",
|
|
checkRouter: checkHTTP,
|
|
expectedError: "malformed HTTP response",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "TCP TLS CatchAll router && HTTP router",
|
|
routers: []applyRouter{routerTCPTLS, routerHTTP},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should be handled by TCP service",
|
|
checkRouter: checkTCPTLS12,
|
|
},
|
|
{
|
|
desc: "HTTP request should be handled by HTTP service",
|
|
checkRouter: checkHTTP,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "TCP CatchAll router && HTTPS router",
|
|
routers: []applyRouter{routerTCPCatchAll, routerHTTPS},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP client sending first bytes should be handled by TCP service",
|
|
checkRouter: checkTCPClientFirst,
|
|
},
|
|
{
|
|
desc: "TCP server sending first bytes should timeout on clientHello",
|
|
checkRouter: checkTCPServerFirst,
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "HTTP request should fail, because handled by TCP service",
|
|
checkRouter: checkHTTP,
|
|
expectedError: "malformed HTTP response",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// We show that a not CatchAll HTTPS router takes priority over a TCP-TLS router.
|
|
desc: "TCP TLS router && HTTPS router",
|
|
routers: []applyRouter{routerTCPTLS, routerHTTPS},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should fail",
|
|
checkRouter: checkTCPTLS12,
|
|
// The connection is handled by the HTTPS router,
|
|
// which has the correct TLS config,
|
|
// but the HTTP server is detecting a malformed request which ends with a timeout.
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should fail",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// We show that a not CatchAll HTTPS router takes priority over a CatchAll TCP-TLS router.
|
|
desc: "TCP TLS CatchAll router && HTTPS router",
|
|
routers: []applyRouter{routerTCPCatchAll, routerHTTPS},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should fail",
|
|
checkRouter: checkTCPTLS12,
|
|
// The connection is handled by the HTTPS router,
|
|
// which has the correct TLS config,
|
|
// but the HTTP server is detecting a malformed request which ends with a timeout.
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should fail",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// We show that TCP-TLS router (not CatchAll) takes priority over non-Host rule HTTPS router (CatchAll).
|
|
desc: "TCP TLS router && HTTPS Path prefix router",
|
|
routers: []applyRouter{routerTCPTLS, routerHTTPSPathPrefix},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should be handled by TCP service",
|
|
checkRouter: checkTCPTLS12,
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should fail",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "malformed HTTP response",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 should fail",
|
|
checkRouter: checkHTTPSTLS12,
|
|
expectedError: "malformed HTTP response",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "TCP TLS router && TCP TLS CatchAll router",
|
|
routers: []applyRouter{routerTCPTLS, routerTCPTLSCatchAll},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should be handled by TCP service",
|
|
checkRouter: checkTCPTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "HTTPS router && HTTPS CatchAll router",
|
|
routers: []applyRouter{routerHTTPS, routerHTTPSPathPrefix},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should fail",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS12,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
desc: "All routers, all checks",
|
|
routers: []applyRouter{routerTCPCatchAll, routerHTTP, routerHTTPS, routerTCPTLS, routerTCPTLSCatchAll},
|
|
checks: []checkCase{
|
|
{
|
|
desc: "TCP client sending first bytes should be handled by TCP service",
|
|
checkRouter: checkTCPClientFirst,
|
|
},
|
|
{
|
|
desc: "TCP server sending first bytes should timeout on clientHello",
|
|
checkRouter: checkTCPServerFirst,
|
|
expectedError: "i/o timeout",
|
|
},
|
|
{
|
|
desc: "HTTP request should fail, because handled by TCP service",
|
|
checkRouter: checkHTTP,
|
|
expectedError: "malformed HTTP response",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.0 request should fail",
|
|
checkRouter: checkHTTPSTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "HTTPS TLS 1.2 request should be handled by HTTPS service",
|
|
checkRouter: checkHTTPSTLS12,
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.0 connection should fail",
|
|
checkRouter: checkTCPTLS10,
|
|
expectedError: "wrong TLS version",
|
|
},
|
|
{
|
|
desc: "TCP TLS 1.2 connection should fail",
|
|
checkRouter: checkTCPTLS12,
|
|
// The connection is handled by the HTTPS router,
|
|
// witch have the correct TLS config,
|
|
// but the HTTP server is detecting a malformed request which ends with a timeout.
|
|
expectedError: "i/o timeout",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dynConf := &runtime.Configuration{
|
|
Routers: map[string]*runtime.RouterInfo{},
|
|
TCPRouters: map[string]*runtime.TCPRouterInfo{},
|
|
}
|
|
|
|
for _, router := range test.routers {
|
|
router(dynConf)
|
|
}
|
|
|
|
router, err := manager.buildEntryPointHandler(context.Background(), dynConf.TCPRouters, dynConf.Routers, nil, nil)
|
|
require.NoError(t, err)
|
|
|
|
epListener, err := net.Listen("tcp", "127.0.0.1:0")
|
|
require.NoError(t, err)
|
|
|
|
// serverHTTP handler returns only the "HTTP" value as body for further checks.
|
|
serverHTTP := &http.Server{
|
|
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, err = fmt.Fprint(w, "HTTP")
|
|
require.NoError(t, err)
|
|
}),
|
|
}
|
|
|
|
stoppedHTTP := make(chan struct{})
|
|
forwarder := newHTTPForwarder(epListener)
|
|
go func() {
|
|
defer close(stoppedHTTP)
|
|
_ = serverHTTP.Serve(forwarder)
|
|
}()
|
|
|
|
router.SetHTTPForwarder(forwarder)
|
|
|
|
// serverHTTPS handler returns only the "HTTPS" value as body for further checks.
|
|
serverHTTPS := &http.Server{
|
|
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, err = fmt.Fprint(w, "HTTPS")
|
|
require.NoError(t, err)
|
|
}),
|
|
}
|
|
|
|
stoppedHTTPS := make(chan struct{})
|
|
httpsForwarder := newHTTPForwarder(epListener)
|
|
go func() {
|
|
defer close(stoppedHTTPS)
|
|
_ = serverHTTPS.Serve(httpsForwarder)
|
|
}()
|
|
|
|
router.SetHTTPSForwarder(httpsForwarder)
|
|
|
|
stoppedTCP := make(chan struct{})
|
|
go func() {
|
|
defer close(stoppedTCP)
|
|
for {
|
|
conn, err := epListener.Accept()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
tcpConn, ok := conn.(*net.TCPConn)
|
|
if !ok {
|
|
t.Error("not a write closer")
|
|
}
|
|
|
|
router.ServeTCP(tcpConn)
|
|
}
|
|
}()
|
|
|
|
for _, check := range test.checks {
|
|
timeout := 2 * time.Second
|
|
if check.timeout > 0 {
|
|
timeout = check.timeout
|
|
}
|
|
|
|
err := check.checkRouter(epListener.Addr().String(), timeout)
|
|
|
|
if check.expectedError != "" {
|
|
require.Error(t, err, check.desc)
|
|
assert.Contains(t, err.Error(), check.expectedError, check.desc)
|
|
continue
|
|
}
|
|
|
|
assert.NoError(t, err, check.desc)
|
|
}
|
|
|
|
epListener.Close()
|
|
|
|
<-stoppedTCP
|
|
|
|
serverHTTP.Close()
|
|
serverHTTPS.Close()
|
|
|
|
<-stoppedHTTP
|
|
<-stoppedHTTPS
|
|
})
|
|
}
|
|
}
|
|
|
|
// routerTCPCatchAll configures a TCP CatchAll No TLS - HostSNI(`*`) router.
|
|
func routerTCPCatchAll(conf *runtime.Configuration) {
|
|
conf.TCPRouters["tcp-catchall"] = &runtime.TCPRouterInfo{
|
|
TCPRouter: &dynamic.TCPRouter{
|
|
EntryPoints: []string{"web"},
|
|
Service: "tcp",
|
|
Rule: "HostSNI(`*`)",
|
|
},
|
|
}
|
|
}
|
|
|
|
// routerHTTP configures an HTTP - Host(`foo.bar`) router.
|
|
func routerHTTP(conf *runtime.Configuration) {
|
|
conf.Routers["http"] = &runtime.RouterInfo{
|
|
Router: &dynamic.Router{
|
|
EntryPoints: []string{"web"},
|
|
Service: "http",
|
|
Rule: "Host(`foo.bar`)",
|
|
},
|
|
}
|
|
}
|
|
|
|
// routerTCPTLSCatchAll a TCP TLS CatchAll - HostSNI(`*`) router with TLS 1.0 config.
|
|
func routerTCPTLSCatchAll(conf *runtime.Configuration) {
|
|
conf.TCPRouters["tcp-tls-catchall"] = &runtime.TCPRouterInfo{
|
|
TCPRouter: &dynamic.TCPRouter{
|
|
EntryPoints: []string{"web"},
|
|
Service: "tcp",
|
|
Rule: "HostSNI(`*`)",
|
|
TLS: &dynamic.RouterTCPTLSConfig{
|
|
Options: "tls10",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// routerTCPTLS configures a TCP TLS - HostSNI(`foo.bar`) router with TLS 1.2 config.
|
|
func routerTCPTLS(conf *runtime.Configuration) {
|
|
conf.TCPRouters["tcp-tls"] = &runtime.TCPRouterInfo{
|
|
TCPRouter: &dynamic.TCPRouter{
|
|
EntryPoints: []string{"web"},
|
|
Service: "tcp",
|
|
Rule: "HostSNI(`foo.bar`)",
|
|
TLS: &dynamic.RouterTCPTLSConfig{
|
|
Options: "tls12",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// routerHTTPSPathPrefix configures an HTTPS - PathPrefix(`/`) router with TLS 1.0 config.
|
|
func routerHTTPSPathPrefix(conf *runtime.Configuration) {
|
|
conf.Routers["https"] = &runtime.RouterInfo{
|
|
Router: &dynamic.Router{
|
|
EntryPoints: []string{"web"},
|
|
Service: "http",
|
|
Rule: "PathPrefix(`/`)",
|
|
TLS: &dynamic.RouterTLSConfig{
|
|
Options: "tls10",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// routerHTTPS configures an HTTPS - Host(`foo.bar`) router with TLS 1.2 config.
|
|
func routerHTTPS(conf *runtime.Configuration) {
|
|
conf.Routers["https-custom-tls"] = &runtime.RouterInfo{
|
|
Router: &dynamic.Router{
|
|
EntryPoints: []string{"web"},
|
|
Service: "http",
|
|
Rule: "Host(`foo.bar`)",
|
|
TLS: &dynamic.RouterTLSConfig{
|
|
Options: "tls12",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// checkTCPClientFirst simulates a TCP client sending first bytes first.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkTCPClientFirst(addr string, timeout time.Duration) (err error) {
|
|
conn, err := net.Dial("tcp", addr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
closeErr := conn.Close()
|
|
if closeErr != nil && err == nil {
|
|
err = closeErr
|
|
}
|
|
}()
|
|
|
|
fmt.Fprint(conn, "HELLO")
|
|
|
|
err = conn.SetReadDeadline(time.Now().Add(timeout))
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
_, err = io.Copy(&buf, conn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !strings.HasPrefix(buf.String(), "TCP-CLIENT-FIRST") {
|
|
return fmt.Errorf("unexpected response: %s", buf.String())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// checkTCPServerFirst simulates a TCP client waiting for the server first bytes.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkTCPServerFirst(addr string, timeout time.Duration) (err error) {
|
|
conn, err := net.Dial("tcp", addr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
closeErr := conn.Close()
|
|
if closeErr != nil && err == nil {
|
|
err = closeErr
|
|
}
|
|
}()
|
|
|
|
err = conn.SetReadDeadline(time.Now().Add(timeout))
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
_, err = io.Copy(&buf, conn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !strings.HasPrefix(buf.String(), "TCP-SERVER-FIRST") {
|
|
return fmt.Errorf("unexpected response: %s", buf.String())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// checkHTTP simulates an HTTP client.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkHTTP(addr string, timeout time.Duration) error {
|
|
httpClient := &http.Client{Timeout: timeout}
|
|
|
|
req, err := http.NewRequest(http.MethodGet, "http://"+addr, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Host", "foo.bar")
|
|
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !strings.Contains(string(body), "HTTP") {
|
|
return fmt.Errorf("unexpected response: %s", string(body))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// checkTCPTLS simulates a TCP client connection.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkTCPTLS(addr string, timeout time.Duration, tlsVersion uint16) (err error) {
|
|
tlsConfig := &tls.Config{
|
|
InsecureSkipVerify: true,
|
|
ServerName: "foo.bar",
|
|
MinVersion: tls.VersionTLS10,
|
|
MaxVersion: tls.VersionTLS12,
|
|
}
|
|
conn, err := tls.Dial("tcp", addr, tlsConfig)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
closeErr := conn.Close()
|
|
if closeErr != nil && err == nil {
|
|
err = closeErr
|
|
}
|
|
}()
|
|
|
|
if conn.ConnectionState().Version != tlsVersion {
|
|
return fmt.Errorf("wrong TLS version. wanted %X, got %X", tlsVersion, conn.ConnectionState().Version)
|
|
}
|
|
|
|
fmt.Fprint(conn, "HELLO")
|
|
|
|
err = conn.SetReadDeadline(time.Now().Add(timeout))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
_, err = io.Copy(&buf, conn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !strings.HasPrefix(buf.String(), "TCP-CLIENT-FIRST") {
|
|
return fmt.Errorf("unexpected response: %s", buf.String())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// checkTCPTLS10 simulates a TCP client connection with TLS 1.0.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkTCPTLS10(addr string, timeout time.Duration) error {
|
|
return checkTCPTLS(addr, timeout, tls.VersionTLS10)
|
|
}
|
|
|
|
// checkTCPTLS12 simulates a TCP client connection with TLS 1.2.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkTCPTLS12(addr string, timeout time.Duration) error {
|
|
return checkTCPTLS(addr, timeout, tls.VersionTLS12)
|
|
}
|
|
|
|
// checkHTTPS makes an HTTPS request and checks the given TLS.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkHTTPS(addr string, timeout time.Duration, tlsVersion uint16) error {
|
|
req, err := http.NewRequest(http.MethodGet, "https://"+addr, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Host", "foo.bar")
|
|
|
|
httpClient := &http.Client{
|
|
Transport: &http.Transport{
|
|
TLSClientConfig: &tls.Config{
|
|
InsecureSkipVerify: true,
|
|
ServerName: "foo.bar",
|
|
MinVersion: tls.VersionTLS10,
|
|
MaxVersion: tls.VersionTLS12,
|
|
},
|
|
},
|
|
Timeout: timeout,
|
|
}
|
|
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.TLS.Version != tlsVersion {
|
|
return fmt.Errorf("wrong TLS version. wanted %X, got %X", tlsVersion, resp.TLS.Version)
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !strings.Contains(string(body), "HTTPS") {
|
|
return fmt.Errorf("unexpected response: %s", string(body))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// checkHTTPSTLS10 makes an HTTP request with TLS version 1.0.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkHTTPSTLS10(addr string, timeout time.Duration) error {
|
|
return checkHTTPS(addr, timeout, tls.VersionTLS10)
|
|
}
|
|
|
|
// checkHTTPSTLS12 makes an HTTP request with TLS version 1.2.
|
|
// It returns an error if it doesn't receive the expected response.
|
|
func checkHTTPSTLS12(addr string, timeout time.Duration) error {
|
|
return checkHTTPS(addr, timeout, tls.VersionTLS12)
|
|
}
|
|
|
|
func TestPostgres(t *testing.T) {
|
|
router, err := NewRouter()
|
|
require.NoError(t, err)
|
|
|
|
// This test requires to have a TLS route, but does not actually check the
|
|
// content of the handler. It would require to code a TLS handshake to
|
|
// check the SNI and content of the handlerFunc.
|
|
err = router.muxerTCPTLS.AddRoute("HostSNI(`test.localhost`)", "", 0, nil)
|
|
require.NoError(t, err)
|
|
|
|
err = router.muxerTCP.AddRoute("HostSNI(`*`)", "", 0, tcp2.HandlerFunc(func(conn tcp2.WriteCloser) {
|
|
_, _ = conn.Write([]byte("OK"))
|
|
_ = conn.Close()
|
|
}))
|
|
require.NoError(t, err)
|
|
|
|
mockConn := NewMockConn()
|
|
go router.ServeTCP(mockConn)
|
|
|
|
mockConn.dataRead <- PostgresStartTLSMsg
|
|
b := <-mockConn.dataWrite
|
|
require.Equal(t, PostgresStartTLSReply, b)
|
|
|
|
mockConn = NewMockConn()
|
|
go router.ServeTCP(mockConn)
|
|
|
|
mockConn.dataRead <- []byte("HTTP")
|
|
b = <-mockConn.dataWrite
|
|
require.Equal(t, []byte("OK"), b)
|
|
}
|
|
|
|
func NewMockConn() *MockConn {
|
|
return &MockConn{
|
|
dataRead: make(chan []byte),
|
|
dataWrite: make(chan []byte),
|
|
}
|
|
}
|
|
|
|
type MockConn struct {
|
|
dataRead chan []byte
|
|
dataWrite chan []byte
|
|
}
|
|
|
|
func (m *MockConn) Read(b []byte) (n int, err error) {
|
|
temp := <-m.dataRead
|
|
copy(b, temp)
|
|
return len(temp), nil
|
|
}
|
|
|
|
func (m *MockConn) Write(b []byte) (n int, err error) {
|
|
m.dataWrite <- b
|
|
return len(b), nil
|
|
}
|
|
|
|
func (m *MockConn) Close() error {
|
|
close(m.dataRead)
|
|
close(m.dataWrite)
|
|
return nil
|
|
}
|
|
|
|
func (m *MockConn) LocalAddr() net.Addr {
|
|
return nil
|
|
}
|
|
|
|
func (m *MockConn) RemoteAddr() net.Addr {
|
|
return &net.TCPAddr{}
|
|
}
|
|
|
|
func (m *MockConn) SetDeadline(t time.Time) error {
|
|
return nil
|
|
}
|
|
|
|
func (m *MockConn) SetReadDeadline(t time.Time) error {
|
|
return nil
|
|
}
|
|
|
|
func (m *MockConn) SetWriteDeadline(t time.Time) error {
|
|
return nil
|
|
}
|
|
|
|
func (m *MockConn) CloseWrite() error {
|
|
close(m.dataRead)
|
|
close(m.dataWrite)
|
|
return nil
|
|
}
|