fix(relay): authenticate endpoints and fail closed on missing routes (#569)

* fix(relay): authenticate endpoints and fail closed on missing routes

* fix(tunnel): retain chains until receiver replacement is acknowledged

* docs: record final relay security review and validation
This commit is contained in:
sagit
2026-11-08 23:46:18 +08:00
committed by GitHub
parent 46bfb86c1b
commit fadc2b6c12
51 changed files with 5562 additions and 277 deletions
@@ -0,0 +1,197 @@
package chain_test
import (
"context"
"crypto/tls"
"crypto/x509"
corechain "github.com/go-gost/core/chain"
"github.com/go-gost/core/connector"
"github.com/go-gost/core/dialer"
"github.com/go-gost/core/handler"
"github.com/go-gost/core/listener"
corelogger "github.com/go-gost/core/logger"
xauth "github.com/go-gost/x/auth"
xchain "github.com/go-gost/x/chain"
relayconnector "github.com/go-gost/x/connector/relay"
kcpdialer "github.com/go-gost/x/dialer/kcp"
relayhandler "github.com/go-gost/x/handler/relay"
netdialer "github.com/go-gost/x/internal/net/dialer"
kcplistener "github.com/go-gost/x/listener/kcp"
tcplistener "github.com/go-gost/x/listener/tcp"
tlslistener "github.com/go-gost/x/listener/tls"
xlogger "github.com/go-gost/x/logger"
"github.com/go-gost/x/metadata"
"io"
"net"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"time"
)
// Local-only matrix: native GOST listeners, relay handler and connectors. The
// credential below is synthetic test data, never used outside loopback sockets.
func TestRelayAuthTransportMatrixInvestigation(t *testing.T) {
log := xlogger.Nop()
corelogger.SetDefault(log)
certServer := httptest.NewTLSServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
cert := certServer.TLS.Certificates[0]
leaf := certServer.Certificate()
certServer.Close()
roots := x509.NewCertPool()
roots.AddCert(leaf)
tcpTarget, e := net.Listen("tcp", "127.0.0.1:0")
if e != nil {
t.Fatal(e)
}
defer tcpTarget.Close()
go func() {
for {
c, e := tcpTarget.Accept()
if e != nil {
return
}
go func() { defer c.Close(); io.Copy(c, c) }()
}
}()
udpTarget, e := net.ListenPacket("udp", "127.0.0.1:0")
if e != nil {
t.Fatal(e)
}
defer udpTarget.Close()
go func() {
buf := make([]byte, 1024)
for {
n, a, e := udpTarget.ReadFrom(buf)
if e != nil {
return
}
udpTarget.WriteTo(buf[:n], a)
}
}()
for _, transport := range []string{"tcp", "tls", "kcp"} {
for _, network := range []string{"tcp", "udp"} {
for _, test := range []struct {
name string
auth bool
credentials *url.Userinfo
success bool
}{
{"legacy-no-credentials", false, nil, true},
{"legacy-valid-credentials", false, url.UserPassword("test-peer", "synthetic-test-secret"), true},
{"secured-no-credentials", true, nil, false},
{"secured-wrong-credentials", true, url.UserPassword("test-peer", "incorrect"), false},
{"secured-valid-credentials", true, url.UserPassword("test-peer", "synthetic-test-secret"), true},
} {
t.Run(transport+"/"+network+"/"+test.name, func(t *testing.T) {
opts := []listener.Option{listener.AddrOption("127.0.0.1:0"), listener.LoggerOption(log), listener.TLSConfigOption(&tls.Config{Certificates: []tls.Certificate{cert}, MinVersion: tls.VersionTLS12})}
var ln listener.Listener
switch transport {
case "tls":
ln = tlslistener.NewListener(opts...)
case "kcp":
ln = kcplistener.NewListener(opts...)
default:
ln = tcplistener.NewListener(opts...)
}
md := metadata.NewMetadata(map[string]any{"kcp.tcp": false, "kcp.nocomp": true})
if e := ln.Init(md); e != nil {
t.Fatal(e)
}
defer ln.Close()
hopts := []handler.Option{handler.RouterOption(xchain.NewRouter(corechain.LoggerRouterOption(log))), handler.LoggerOption(log), handler.ServiceOption("auth-investigation")}
if test.auth {
au := xauth.NewAuthenticator(xauth.AuthsOption(map[string]string{"test-peer": "synthetic-test-secret"}))
if closer, ok := au.(io.Closer); ok {
defer closer.Close()
}
hopts = append(hopts, handler.AutherOption(au))
}
h := relayhandler.NewHandler(hopts...)
if e := h.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
if closer, ok := h.(io.Closer); ok {
defer closer.Close()
}
handled := make(chan struct{})
go func() {
defer close(handled)
c, e := ln.Accept()
if e == nil {
h.Handle(context.Background(), c)
}
}()
var raw net.Conn
var err error
switch transport {
case "tls":
raw, err = tls.DialWithDialer(&net.Dialer{Timeout: time.Second}, "tcp", ln.Addr().String(), &tls.Config{RootCAs: roots, MinVersion: tls.VersionTLS12})
case "kcp":
d := kcpdialer.NewDialer(dialer.LoggerOption(log))
if e := d.Init(md); e != nil {
t.Fatal(e)
}
if closer, ok := d.(io.Closer); ok {
defer closer.Close()
}
raw, err = d.Dial(context.Background(), ln.Addr().String(), dialer.NetDialerDialOption(&netdialer.Dialer{Logger: log}))
default:
raw, err = net.DialTimeout("tcp", ln.Addr().String(), time.Second)
}
if err != nil {
t.Fatal(err)
}
defer raw.Close()
raw.SetDeadline(time.Now().Add(5 * time.Second))
copts := []connector.Option{connector.LoggerOption(log)}
if test.credentials != nil {
copts = append(copts, connector.AuthOption(test.credentials))
}
client := relayconnector.NewConnector(copts...)
if e := client.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
target := tcpTarget.Addr().String()
if network == "udp" {
target = udpTarget.LocalAddr().String()
}
conn, err := client.Connect(context.Background(), raw, network, target)
if !test.success {
if err == nil {
t.Fatal("unauthorized client was accepted")
}
if !strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
t.Fatalf("expected authentication refusal, got %v", err)
}
raw.Close()
<-handled
return
}
if err != nil {
t.Fatal(err)
}
if _, err = conn.Write([]byte("probe")); err != nil {
t.Fatal(err)
}
b := make([]byte, 64)
n, err := conn.Read(b)
if err != nil {
t.Fatal(err)
}
if string(b[:n]) != "probe" {
t.Fatalf("unexpected response %q", b[:n])
}
raw.Close()
select {
case <-handled:
case <-time.After(5 * time.Second):
t.Fatal("handler did not close")
}
})
}
}
}
}
@@ -0,0 +1,151 @@
package chain_test
import (
"context"
corechain "github.com/go-gost/core/chain"
"github.com/go-gost/core/connector"
"github.com/go-gost/core/handler"
corelogger "github.com/go-gost/core/logger"
xchain "github.com/go-gost/x/chain"
"github.com/go-gost/x/config"
parser "github.com/go-gost/x/config/parsing/chain"
relayconnector "github.com/go-gost/x/connector/relay"
_ "github.com/go-gost/x/dialer/tcp"
relayhandler "github.com/go-gost/x/handler/relay"
xlogger "github.com/go-gost/x/logger"
"github.com/go-gost/x/metadata"
"github.com/go-gost/x/registry"
"io"
"net"
"sync/atomic"
"testing"
"time"
)
// This test documents existing fail-open behavior, not desired secure behavior.
// Every socket is bound to 127.0.0.1, no production config or external target.
func TestRelayMissingChainDataPathInvestigation(t *testing.T) {
log := xlogger.Nop()
originalLogger := corelogger.Default()
corelogger.SetDefault(log)
if originalLogger != nil {
defer corelogger.SetDefault(originalLogger)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
target, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer target.Close()
go func() {
for {
c, e := target.Accept()
if e != nil {
return
}
go func() { defer c.Close(); io.Copy(c, c) }()
}
}()
type relay struct {
addr string
count *atomic.Int32
}
start := func(name, chainName string) relay {
ln, e := net.Listen("tcp", "127.0.0.1:0")
if e != nil {
t.Fatal(e)
}
t.Cleanup(func() { ln.Close() })
router := xchain.NewRouter(corechain.ChainRouterOption(registry.ChainRegistry().Get(chainName)), corechain.LoggerRouterOption(log))
h := relayhandler.NewHandler(handler.RouterOption(router), handler.LoggerOption(log), handler.ServiceOption(name))
if e := h.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
t.Cleanup(func() {
if closer, ok := h.(io.Closer); ok {
closer.Close()
}
})
count := &atomic.Int32{}
go func() {
for {
c, e := ln.Accept()
if e != nil {
return
}
count.Add(1)
go h.Handle(ctx, c)
}
}()
return relay{ln.Addr().String(), count}
}
replace := func(name, addr string) {
c, e := parser.ParseChain(&config.ChainConfig{Name: name, Hops: []*config.HopConfig{{Name: name + "-hop", Nodes: []*config.NodeConfig{{Name: name + "-next", Addr: addr, Connector: &config.ConnectorConfig{Type: "relay", Metadata: map[string]any{"nodelay": true}}, Dialer: &config.DialerConfig{Type: "tcp"}}}}}}, log)
if e != nil {
t.Fatal(e)
}
if e = registry.ReplaceChain(name, c); e != nil {
t.Fatal(e)
}
}
for _, name := range []string{"investigation-A", "investigation-B", "investigation-C"} {
name := name
t.Cleanup(func() { registry.ChainRegistry().Unregister(name) })
}
d := start("D", "")
c := start("C", "investigation-C")
replace("investigation-C", d.addr)
b := start("B", "investigation-B")
replace("investigation-B", d.addr)
a := start("A", "investigation-A")
replace("investigation-A", b.addr)
request := func() {
raw, e := net.DialTimeout("tcp", a.addr, time.Second)
if e != nil {
t.Fatal(e)
}
defer raw.Close()
raw.SetDeadline(time.Now().Add(3 * time.Second))
client := relayconnector.NewConnector(connector.LoggerOption(log))
if e := client.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
conn, e := client.Connect(ctx, raw, "tcp", target.Addr().String())
if e != nil {
t.Fatal(e)
}
if _, e = conn.Write([]byte("probe")); e != nil {
t.Fatal(e)
}
buf := make([]byte, 5)
if _, e = io.ReadFull(conn, buf); e != nil {
t.Fatal(e)
}
if string(buf) != "probe" {
t.Fatalf("bad response %q", buf)
}
}
request()
if b.count.Load() != 1 || c.count.Load() != 0 || d.count.Load() != 1 {
t.Fatalf("initial B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
replace("investigation-B", c.addr)
request()
if b.count.Load() != 2 || c.count.Load() != 1 || d.count.Load() != 2 {
t.Fatalf("insert C B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
// Deterministic cleanup boundary: DeleteChains has completed, while the B
// relay service is still alive (before a subsequent DeleteService command).
registry.ChainRegistry().Unregister("investigation-B")
request()
if b.count.Load() != 3 || c.count.Load() != 1 || d.count.Load() != 2 {
t.Fatalf("missing chain B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
t.Log("Confirmed real relay data flow: A-B-D, then A-B-C-D, then A-B-target with B chain missing; no credentials supplied")
replace("investigation-B", c.addr)
request()
if b.count.Load() != 4 || c.count.Load() != 2 || d.count.Load() != 3 {
t.Fatalf("restored B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
}
@@ -0,0 +1,190 @@
package chain_test
import (
"context"
"io"
"net"
"net/url"
"sync/atomic"
"testing"
"time"
corechain "github.com/go-gost/core/chain"
"github.com/go-gost/core/connector"
"github.com/go-gost/core/handler"
corelogger "github.com/go-gost/core/logger"
xauth "github.com/go-gost/x/auth"
xchain "github.com/go-gost/x/chain"
"github.com/go-gost/x/config"
parser "github.com/go-gost/x/config/parsing/chain"
relayconnector "github.com/go-gost/x/connector/relay"
_ "github.com/go-gost/x/dialer/tcp"
relayhandler "github.com/go-gost/x/handler/relay"
xlogger "github.com/go-gost/x/logger"
"github.com/go-gost/x/metadata"
"github.com/go-gost/x/registry"
)
// This regression uses real loopback GOST relay endpoints and verifies the required-route policy.
// Every socket is bound to 127.0.0.1, no production config or external target.
func TestRequiredRelayRouteRejectsMissingHopAndRecovers(t *testing.T) {
testRequiredRelayRecovery(t, false)
}
func TestRequiredAuthenticatedRelayRouteRejectsMissingHopAndRecovers(t *testing.T) {
testRequiredRelayRecovery(t, true)
}
func testRequiredRelayRecovery(t *testing.T, authenticated bool) {
t.Helper()
log := xlogger.Nop()
originalLogger := corelogger.Default()
corelogger.SetDefault(log)
if originalLogger != nil {
defer corelogger.SetDefault(originalLogger)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
target, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer target.Close()
go func() {
for {
c, e := target.Accept()
if e != nil {
return
}
go func() { defer c.Close(); io.Copy(c, c) }()
}
}()
type relay struct {
name string
addr string
count *atomic.Int32
}
start := func(name, chainName string) relay {
ln, e := net.Listen("tcp", "127.0.0.1:0")
if e != nil {
t.Fatal(e)
}
t.Cleanup(func() { ln.Close() })
router := xchain.NewRouter(corechain.ChainRouterOption(registry.ChainRegistry().Get(chainName)), corechain.LoggerRouterOption(log))
if chainName != "" {
router.WithRequiredChain()
}
opts := []handler.Option{handler.RouterOption(router), handler.LoggerOption(log), handler.ServiceOption(name)}
if authenticated {
au := xauth.NewAuthenticator(xauth.AuthsOption(map[string]string{name: "synthetic-local-password-for-" + name}))
if closer, ok := au.(io.Closer); ok {
t.Cleanup(func() { closer.Close() })
}
opts = append(opts, handler.AutherOption(au))
}
h := relayhandler.NewHandler(opts...)
if e := h.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
t.Cleanup(func() {
if closer, ok := h.(io.Closer); ok {
closer.Close()
}
})
count := &atomic.Int32{}
go func() {
for {
c, e := ln.Accept()
if e != nil {
return
}
count.Add(1)
go h.Handle(ctx, c)
}
}()
return relay{name, ln.Addr().String(), count}
}
replace := func(name string, next relay) {
connectorConfig := &config.ConnectorConfig{Type: "relay", Metadata: map[string]any{"nodelay": true}}
if authenticated {
connectorConfig.Auth = &config.AuthConfig{Username: next.name, Password: "synthetic-local-password-for-" + next.name}
}
c, e := parser.ParseChain(&config.ChainConfig{Name: name, Hops: []*config.HopConfig{{Name: name + "-hop", Nodes: []*config.NodeConfig{{Name: name + "-next", Addr: next.addr, Connector: connectorConfig, Dialer: &config.DialerConfig{Type: "tcp"}}}}}}, log)
if e != nil {
t.Fatal(e)
}
if e = registry.ReplaceChain(name, c); e != nil {
t.Fatal(e)
}
}
for _, name := range []string{"strict-regression-A", "strict-regression-B", "strict-regression-C"} {
name := name
t.Cleanup(func() { registry.ChainRegistry().Unregister(name) })
}
d := start("D", "")
c := start("C", "strict-regression-C")
replace("strict-regression-C", d)
b := start("B", "strict-regression-B")
replace("strict-regression-B", d)
a := start("A", "strict-regression-A")
replace("strict-regression-A", b)
request := func(wantSuccess bool) {
raw, e := net.DialTimeout("tcp", a.addr, time.Second)
if e != nil {
t.Fatal(e)
}
defer raw.Close()
raw.SetDeadline(time.Now().Add(3 * time.Second))
opts := []connector.Option{connector.LoggerOption(log)}
if authenticated {
opts = append(opts, connector.AuthOption(url.UserPassword("A", "synthetic-local-password-for-A")))
}
client := relayconnector.NewConnector(opts...)
if e := client.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
conn, e := client.Connect(ctx, raw, "tcp", target.Addr().String())
if !wantSuccess {
if e == nil {
conn.Close()
t.Fatal("relay connected through a missing required hop")
}
return
}
if e != nil {
t.Fatal(e)
}
if _, e = conn.Write([]byte("probe")); e != nil {
t.Fatal(e)
}
buf := make([]byte, 5)
if _, e = io.ReadFull(conn, buf); e != nil {
t.Fatal(e)
}
if string(buf) != "probe" {
t.Fatalf("bad response %q", buf)
}
}
request(true)
if b.count.Load() != 1 || c.count.Load() != 0 || d.count.Load() != 1 {
t.Fatalf("initial B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
replace("strict-regression-B", c)
request(true)
if b.count.Load() != 2 || c.count.Load() != 1 || d.count.Load() != 2 {
t.Fatalf("insert C B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
// Deterministic cleanup boundary: DeleteChains has completed, while the B
// relay service is still alive (before a subsequent DeleteService command).
registry.ChainRegistry().Unregister("strict-regression-B")
request(false)
if b.count.Load() != 3 || c.count.Load() != 1 || d.count.Load() != 2 {
t.Fatalf("missing chain B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
t.Log("Required route refuses the missing B chain and recovers after replacement")
replace("strict-regression-B", c)
request(true)
if b.count.Load() != 4 || c.count.Load() != 2 || d.count.Load() != 3 {
t.Fatalf("restored B/C/D: %d/%d/%d", b.count.Load(), c.count.Load(), d.count.Load())
}
}
@@ -0,0 +1,100 @@
package chain_test
import (
"context"
"crypto/tls"
"io"
"net"
"sync/atomic"
"testing"
"time"
"github.com/go-gost/core/connector"
corelogger "github.com/go-gost/core/logger"
"github.com/go-gost/x/config"
"github.com/go-gost/x/config/parsing"
chainparser "github.com/go-gost/x/config/parsing/chain"
serviceparser "github.com/go-gost/x/config/parsing/service"
relayconnector "github.com/go-gost/x/connector/relay"
_ "github.com/go-gost/x/handler/relay"
_ "github.com/go-gost/x/listener/tcp"
xlogger "github.com/go-gost/x/logger"
"github.com/go-gost/x/metadata"
"github.com/go-gost/x/registry"
)
func TestRequiredRelayChainCannotDialTargetWhenMissing(t *testing.T) {
assertRequiredRelayCannotDial(t, "missing-required-chain", "tcp")
}
func TestRequiredRelayChainRejectsEmptySelectionAndAbsentConfiguration(t *testing.T) {
corelogger.SetDefault(xlogger.Nop())
const name = "empty-required-chain"
c, err := chainparser.ParseChain(&config.ChainConfig{Name: name, Hops: []*config.HopConfig{{Name: "empty-hop", Nodes: []*config.NodeConfig{}}}}, xlogger.Nop())
if err != nil {
t.Fatal(err)
}
if err := registry.ReplaceChain(name, c); err != nil {
t.Fatal(err)
}
defer registry.ChainRegistry().Unregister(name)
for _, network := range []string{"tcp", "udp"} {
for _, chainName := range []string{name, ""} {
t.Run(network+"/"+chainName, func(t *testing.T) { assertRequiredRelayCannotDial(t, chainName, network) })
}
}
}
func assertRequiredRelayCannotDial(t *testing.T, chainName, network string) {
t.Helper()
corelogger.SetDefault(xlogger.Nop())
previousTLS := parsing.DefaultTLSConfig()
parsing.SetDefaultTLSConfig(&tls.Config{})
defer parsing.SetDefaultTLSConfig(previousTLS)
target, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer target.Close()
var accepted atomic.Int32
go func() {
for {
c, e := target.Accept()
if e != nil {
return
}
accepted.Add(1)
c.Close()
}
}()
svc, err := serviceparser.ParseService(&config.ServiceConfig{Name: "required-route-regression", Addr: "127.0.0.1:0", Listener: &config.ListenerConfig{Type: "tcp"}, Handler: &config.HandlerConfig{Type: "relay", Chain: chainName, Metadata: map[string]any{"chain.strict": true, "nodelay": true}}})
if err != nil {
t.Fatal(err)
}
done := make(chan struct{})
go func() { defer close(done); svc.Serve() }()
defer func() { svc.Close(); <-done }()
raw, err := net.DialTimeout("tcp", svc.Addr().String(), time.Second)
if err != nil {
t.Fatal(err)
}
defer raw.Close()
raw.SetDeadline(time.Now().Add(3 * time.Second))
client := relayconnector.NewConnector(connector.LoggerOption(xlogger.Nop()))
if err := client.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); err != nil {
t.Fatal(err)
}
conn, err := client.Connect(context.Background(), raw, network, target.Addr().String())
if err == nil {
if conn != nil {
conn.Close()
}
t.Fatal("required chain is missing, but relay accepted a direct connection")
}
if accepted.Load() != 0 {
t.Fatalf("ultimate target received %d connections without the required chain", accepted.Load())
}
if closer, ok := client.(io.Closer); ok {
closer.Close()
}
}
@@ -0,0 +1,196 @@
package chain_test
import (
"context"
"crypto/tls"
"crypto/x509"
"io"
"net"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"time"
corechain "github.com/go-gost/core/chain"
"github.com/go-gost/core/connector"
"github.com/go-gost/core/dialer"
"github.com/go-gost/core/handler"
"github.com/go-gost/core/listener"
corelogger "github.com/go-gost/core/logger"
xauth "github.com/go-gost/x/auth"
xchain "github.com/go-gost/x/chain"
relayconnector "github.com/go-gost/x/connector/relay"
kcpdialer "github.com/go-gost/x/dialer/kcp"
relayhandler "github.com/go-gost/x/handler/relay"
netdialer "github.com/go-gost/x/internal/net/dialer"
kcplistener "github.com/go-gost/x/listener/kcp"
tcplistener "github.com/go-gost/x/listener/tcp"
tlslistener "github.com/go-gost/x/listener/tls"
xlogger "github.com/go-gost/x/logger"
"github.com/go-gost/x/metadata"
)
// Required intermediates reject missing chains on every supported transport.
// Legitimate authenticated exits remain direct. All credentials and endpoints are local test data.
func TestRequiredRelayRouteTransportMatrix(t *testing.T) {
log := xlogger.Nop()
corelogger.SetDefault(log)
certServer := httptest.NewTLSServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
cert := certServer.TLS.Certificates[0]
leaf := certServer.Certificate()
certServer.Close()
roots := x509.NewCertPool()
roots.AddCert(leaf)
tcpTarget, e := net.Listen("tcp", "127.0.0.1:0")
if e != nil {
t.Fatal(e)
}
defer tcpTarget.Close()
go func() {
for {
c, e := tcpTarget.Accept()
if e != nil {
return
}
go func() { defer c.Close(); io.Copy(c, c) }()
}
}()
udpTarget, e := net.ListenPacket("udp", "127.0.0.1:0")
if e != nil {
t.Fatal(e)
}
defer udpTarget.Close()
go func() {
buf := make([]byte, 1024)
for {
n, a, e := udpTarget.ReadFrom(buf)
if e != nil {
return
}
udpTarget.WriteTo(buf[:n], a)
}
}()
for _, transport := range []string{"tcp", "tls", "kcp"} {
for _, network := range []string{"tcp", "udp"} {
for _, test := range []struct {
name string
required bool
credentials *url.Userinfo
success bool
}{
{"authenticated-exit", false, url.UserPassword("test-peer", "synthetic-test-secret"), true},
{"required-missing-chain", true, url.UserPassword("test-peer", "synthetic-test-secret"), false},
} {
t.Run(transport+"/"+network+"/"+test.name, func(t *testing.T) {
opts := []listener.Option{listener.AddrOption("127.0.0.1:0"), listener.LoggerOption(log), listener.TLSConfigOption(&tls.Config{Certificates: []tls.Certificate{cert}, MinVersion: tls.VersionTLS12})}
var ln listener.Listener
switch transport {
case "tls":
ln = tlslistener.NewListener(opts...)
case "kcp":
ln = kcplistener.NewListener(opts...)
default:
ln = tcplistener.NewListener(opts...)
}
md := metadata.NewMetadata(map[string]any{"kcp.tcp": false, "kcp.nocomp": true})
if e := ln.Init(md); e != nil {
t.Fatal(e)
}
defer ln.Close()
router := xchain.NewRouter(corechain.LoggerRouterOption(log))
if test.required {
router.WithRequiredChain()
}
hopts := []handler.Option{handler.RouterOption(router), handler.LoggerOption(log), handler.ServiceOption("strict-transport-regression")}
{
au := xauth.NewAuthenticator(xauth.AuthsOption(map[string]string{"test-peer": "synthetic-test-secret"}))
if closer, ok := au.(io.Closer); ok {
defer closer.Close()
}
hopts = append(hopts, handler.AutherOption(au))
}
h := relayhandler.NewHandler(hopts...)
if e := h.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
if closer, ok := h.(io.Closer); ok {
defer closer.Close()
}
handled := make(chan struct{})
go func() {
defer close(handled)
c, e := ln.Accept()
if e == nil {
h.Handle(context.Background(), c)
}
}()
var raw net.Conn
var err error
switch transport {
case "tls":
raw, err = tls.DialWithDialer(&net.Dialer{Timeout: time.Second}, "tcp", ln.Addr().String(), &tls.Config{RootCAs: roots, MinVersion: tls.VersionTLS12})
case "kcp":
d := kcpdialer.NewDialer(dialer.LoggerOption(log))
if e := d.Init(md); e != nil {
t.Fatal(e)
}
if closer, ok := d.(io.Closer); ok {
defer closer.Close()
}
raw, err = d.Dial(context.Background(), ln.Addr().String(), dialer.NetDialerDialOption(&netdialer.Dialer{Logger: log}))
default:
raw, err = net.DialTimeout("tcp", ln.Addr().String(), time.Second)
}
if err != nil {
t.Fatal(err)
}
defer raw.Close()
raw.SetDeadline(time.Now().Add(5 * time.Second))
copts := []connector.Option{connector.LoggerOption(log)}
if test.credentials != nil {
copts = append(copts, connector.AuthOption(test.credentials))
}
client := relayconnector.NewConnector(copts...)
if e := client.Init(metadata.NewMetadata(map[string]any{"nodelay": true})); e != nil {
t.Fatal(e)
}
target := tcpTarget.Addr().String()
if network == "udp" {
target = udpTarget.LocalAddr().String()
}
conn, err := client.Connect(context.Background(), raw, network, target)
if !test.success {
if err == nil {
t.Fatal("required route missing but direct connection accepted")
}
raw.Close()
<-handled
return
}
if err != nil {
t.Fatal(err)
}
if _, err = conn.Write([]byte("probe")); err != nil {
t.Fatal(err)
}
b := make([]byte, 64)
n, err := conn.Read(b)
if err != nil {
t.Fatal(err)
}
if string(b[:n]) != "probe" {
t.Fatalf("unexpected response %q", b[:n])
}
raw.Close()
select {
case <-handled:
case <-time.After(5 * time.Second):
t.Fatal("handler did not close")
}
})
}
}
}
}
+16 -1
View File
@@ -15,7 +15,8 @@ import (
)
type Router struct {
options chain.RouterOptions
options chain.RouterOptions
requireChain bool
}
func NewRouter(opts ...chain.RouterOption) *Router {
@@ -35,6 +36,13 @@ func NewRouter(opts ...chain.RouterOption) *Router {
return r
}
// WithRequiredChain disables direct fallback when an explicitly required chain
// is absent or selects no route. Configure it before serving requests.
func (r *Router) WithRequiredChain() *Router {
r.requireChain = true
return r
}
func (r *Router) Options() *chain.RouterOptions {
if r == nil {
return nil
@@ -117,6 +125,10 @@ func (r *Router) dial(ctx context.Context, network, address string, log logger.L
route = r.options.Chain.Route(ctx, network, ipAddr, chain.WithHostRouteOption(address))
}
if r.requireChain && (route == nil || len(route.Nodes()) == 0) {
return nil, ErrEmptyRoute
}
if buf == nil {
buf = &bytes.Buffer{}
}
@@ -164,6 +176,9 @@ func (r *Router) Bind(ctx context.Context, network, address string, opts ...chai
defer cancel()
}
if r.requireChain && r.options.Chain == nil {
return nil, ErrEmptyRoute
}
var route chain.Route
if r.options.Chain != nil {
route = r.options.Chain.Route(ctx, network, address)