Skip to content

Agent Mesh

address reviews: validate hub public key size, add validation tests, and decouple node/hub initialization from start lifecycle

Antonio Ojeac4ce58b680d2
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.go
index 68a20530..a4713b1f 100644
--- a/cmd/sam-hub/main.go
+++ b/cmd/sam-hub/main.go
@@ -142,7 +142,7 @@ func main() {
Policy: policyConfig,
}
- h, err := hub.NewHub(ctx, hOpts)
+ h, err := hub.NewHub(hOpts)
if err != nil {
logger.Fatal(err)
}
@@ -152,11 +152,8 @@ func main() {
}
}()
- // Start key rotation if enabled
- h.StartRotation(ctx)
-
- if len(externalMultiaddrs) > 0 {
- go h.StartBootstrapFederation(ctx, externalMultiaddrs)
+ if err := h.Start(ctx); err != nil {
+ logger.Fatalf("Failed to start hub: %v", err)
}
mux := http.NewServeMux()
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index d6053073..03d4508a 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -187,9 +187,13 @@ func main() {
}
}
logger.Infof("No identity found. Starting unauthenticated sidecar for enrollment over MCP...")
- if err := node.StartUnauthSidecarServer(displayHub, bindAddrFlag, tlsCertFlag, tlsKeyFlag); err != nil {
+ unauthSrv, err := node.StartUnauthSidecarServer(displayHub, bindAddrFlag, tlsCertFlag, tlsKeyFlag)
+ if err != nil {
logger.Fatalf("Failed to start unauthenticated sidecar: %v", err)
}
+ defer func() {
+ _ = unauthSrv.Close()
+ }()
<-ctx.Done()
return
}
@@ -199,7 +203,7 @@ func main() {
logger.Fatal("Hub public key not found in store and not provided. Cannot verify peers.")
}
priv := node.GetOrGenerateKey(store)
- meshNode, err = node.NewSamNode(context.Background(), node.Options{
+ meshNode, err = node.NewSamNode(node.Options{
PrivKey: priv,
HubPubKey: hubPubKey,
HubAddrs: hubAddrs,
@@ -218,6 +222,9 @@ func main() {
AutoRelayBackoff: autoRelayBackoffFlag,
})
if err != nil {
+ logger.Fatalf("Failed to initialize mesh node: %v", err)
+ }
+ if err := meshNode.Start(ctx); err != nil {
logger.Fatalf("Failed to start mesh node: %v", err)
}
} else {
@@ -255,7 +262,7 @@ func main() {
priv := node.GetOrGenerateKey(store)
enrollCtx, enrollCancel := context.WithCancel(context.Background())
- meshNode, err = node.NewSamNode(enrollCtx, node.Options{
+ meshNode, err = node.NewSamNode(node.Options{
PrivKey: priv,
HubAddrs: initHubAddrs,
Store: store,
@@ -276,6 +283,10 @@ func main() {
enrollCancel()
logger.Fatalf("Failed to initialize node for enrollment: %v", err)
}
+ if err := meshNode.Start(enrollCtx); err != nil {
+ enrollCancel()
+ logger.Fatalf("Failed to start node for enrollment: %v", err)
+ }
err = meshNode.Enroll(enrollCtx, hubAddr, jwtStr)
if err != nil {
@@ -301,7 +312,7 @@ func main() {
hubPubKey = storedPubKey
logger.Debugf("listenAddrs: %v, allowLoopback: %v", listenAddrs, allowLoopbackFlag)
- meshNode, err = node.NewSamNode(context.Background(), node.Options{
+ meshNode, err = node.NewSamNode(node.Options{
PrivKey: priv,
HubPubKey: hubPubKey,
HubAddrs: newHubAddrs,
@@ -320,7 +331,10 @@ func main() {
AutoRelayBackoff: autoRelayBackoffFlag,
})
if err != nil {
- logger.Fatalf("Failed to start mesh node after enrollment: %v", err)
+ logger.Fatalf("Failed to initialize node after enrollment: %v", err)
+ }
+ if err := meshNode.Start(ctx); err != nil {
+ logger.Fatalf("Failed to start node after enrollment: %v", err)
}
}
@@ -337,9 +351,13 @@ func main() {
meshNode.Host.SetStreamHandler(api.AuthProtocolID, meshNode.HandleAuthHandshake)
// Start Sidecar API Server (multiplexed with MCP)
- if err := node.StartSidecarServer(meshNode, bindAddrFlag, apiTokenFlag, tlsCertFlag, tlsKeyFlag, tlsCAFlag); err != nil {
+ sidecarSrv, err := node.StartSidecarServer(meshNode, bindAddrFlag, apiTokenFlag, tlsCertFlag, tlsKeyFlag, tlsCAFlag)
+ if err != nil {
logger.Fatalf("Failed to start sidecar server: %v", err)
}
+ defer func() {
+ _ = sidecarSrv.Close()
+ }()
fmt.Printf("SAM Node Online.\nPeerID: %s\nListening on: %v\n", meshNode.Host.ID(), meshNode.Host.Addrs())
@@ -449,7 +467,7 @@ func main() {
}
priv := node.GetOrGenerateKey(store)
- meshNode, err := node.NewSamNode(context.Background(), node.Options{
+ meshNode, err := node.NewSamNode(node.Options{
PrivKey: priv,
HubAddrs: initHubAddrs,
Store: store,
@@ -469,6 +487,9 @@ func main() {
if err != nil {
logger.Fatalf("Failed to initialize node for enrollment: %v", err)
}
+ if err := meshNode.Start(ctx); err != nil {
+ logger.Fatalf("Failed to start node for enrollment: %v", err)
+ }
err = meshNode.Enroll(context.Background(), targetHub, jwtStr)
if err != nil {
diff --git a/cmd/sam-node/stdio_bridge.go_patch b/cmd/sam-node/stdio_bridge.go_patch
deleted file mode 100644
index 77fd32d9..00000000
--- a/cmd/sam-node/stdio_bridge.go_patch
+++ /dev/null
@@ -1 +0,0 @@
-func (b *StdioBridge) Start() {
diff --git a/internal/hub/hub.go b/internal/hub/hub.go
index 415c24a1..eca7d328 100644
--- a/internal/hub/hub.go
+++ b/internal/hub/hub.go
@@ -100,6 +100,7 @@ func (a *relayACL) AllowConnect(src peer.ID, srcAddr multiaddr.Multiaddr, dest p
// Hub handles identity bridging and network discovery
type Hub struct {
+ config Options
Host host.Host
DHT *dht.IpfsDHT
Providers map[string]*oidc.Provider
@@ -122,29 +123,62 @@ type Hub struct {
isReady atomic.Bool
}
-// NewHub starts a host supporting both QUIC and TCP (with TLS 1.3)
-func NewHub(ctx context.Context, config Options) (*Hub, error) {
+// NewHub initializes configuration and KeyRing without starting background tasks or network interfaces.
+func NewHub(config Options) (*Hub, error) {
config.Default()
if err := config.Validate(); err != nil {
return nil, err
}
+ var initialSeed []byte
+ if config.BiscuitHex != "" {
+ var err error
+ initialSeed, err = hex.DecodeString(strings.TrimSpace(config.BiscuitHex))
+ if err != nil {
+ return nil, fmt.Errorf("failed to decode key flag: %w", err)
+ }
+ }
+ kr, err := NewKeyRing(config.KeysDBPath, config.KeyGracePeriod, initialSeed)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create keyring: %w", err)
+ }
+
+ hub := &Hub{
+ config: config,
+ KeyRing: kr,
+ MeshID: config.MeshName,
+ Policy: config.Policy,
+ limiter: rate.NewLimiter(rate.Limit(EnrollRateLimit), EnrollBurst),
+ AllowedAudiences: config.AllowedAudiences,
+ AllowLoopback: config.AllowLoopback,
+ logger: golog.Logger("sam-hub"),
+ oidcIssuer: config.OIDCIssuer,
+ keyRotationInterval: config.KeyRotationInterval,
+ keyGracePeriod: config.KeyGracePeriod,
+ insecureSkipTLSVerify: config.InsecureSkipTLSVerify,
+ }
+
+ return hub, nil
+}
+
+// Start initializes the libp2p host, DHT, PubSub, OIDC providers, and starts runtime components.
+func (h *Hub) Start(ctx context.Context) error {
// Connection Manager for DoS protection
cm, err := connmgr.NewConnManager(LowWaterMark, HighWaterMark, connmgr.WithGracePeriod(ConnGracePeriod))
if err != nil {
- return nil, fmt.Errorf("failed to create connection manager: %w", err)
+ return fmt.Errorf("failed to create connection manager: %w", err)
}
p2pOpts := []libp2p.Option{
libp2p.DefaultTransports,
- libp2p.ListenAddrStrings(config.ListenAddrs...),
+ libp2p.ListenAddrStrings(h.config.ListenAddrs...),
// FIPS compliant Security
libp2p.Security(libp2ptls.ID, libp2ptls.New),
libp2p.ConnectionManager(cm),
libp2p.EnableAutoNATv2(),
libp2p.EnableNATService(),
libp2p.AddrsFactory(func(addrs []multiaddr.Multiaddr) []multiaddr.Multiaddr {
- if config.AllowLoopback {
+ if h.config.AllowLoopback {
return addrs
}
var filtered []multiaddr.Multiaddr
@@ -157,22 +191,23 @@ func NewHub(ctx context.Context, config Options) (*Hub, error) {
}),
}
- h, err := libp2p.New(p2pOpts...)
+ hostNode, err := libp2p.New(p2pOpts...)
if err != nil {
- return nil, err
+ return err
}
+ h.Host = hostNode
- kadDHT, err := dht.New(ctx, h, dht.Mode(dht.ModeServer), dht.ProtocolPrefix("/sam"))
+ kadDHT, err := dht.New(ctx, hostNode, dht.Mode(dht.ModeServer), dht.ProtocolPrefix("/sam"))
if err != nil {
- _ = h.Close()
- return nil, err
+ return err
}
+ h.DHT = kadDHT
+
if err = kadDHT.Bootstrap(ctx); err != nil {
- _ = h.Close()
- return nil, err
+ return err
}
- issuers := strings.Split(config.OIDCIssuer, ",")
+ issuers := strings.Split(h.config.OIDCIssuer, ",")
providers := make(map[string]*oidc.Provider)
for _, iss := range issuers {
iss = strings.TrimSpace(iss)
@@ -180,7 +215,7 @@ func NewHub(ctx context.Context, config Options) (*Hub, error) {
continue
}
var providerCtx = ctx
- if config.InsecureSkipTLSVerify {
+ if h.config.InsecureSkipTLSVerify {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
@@ -192,86 +227,59 @@ func NewHub(ctx context.Context, config Options) (*Hub, error) {
}
provider, err := oidc.NewProvider(providerCtx, iss)
if err != nil {
- _ = h.Close()
- return nil, fmt.Errorf("failed to create provider for %s: %w", iss, err)
+ return fmt.Errorf("failed to create provider for %s: %w", iss, err)
}
providers[iss] = provider
}
-
- var initialSeed []byte
- if config.BiscuitHex != "" {
- var err error
- initialSeed, err = hex.DecodeString(strings.TrimSpace(config.BiscuitHex))
- if err != nil {
- _ = h.Close()
- return nil, fmt.Errorf("failed to decode key flag: %w", err)
- }
- }
- kr, err := NewKeyRing(config.KeysDBPath, config.KeyGracePeriod, initialSeed)
- if err != nil {
- _ = h.Close()
- return nil, fmt.Errorf("failed to create keyring: %w", err)
- }
+ h.Providers = providers
var filteredExternal []string
- for _, addr := range config.ExternalMultiaddrs {
+ for _, addr := range h.config.ExternalMultiaddrs {
if !strings.HasPrefix(addr, "http://") && !strings.HasPrefix(addr, "https://") {
filteredExternal = append(filteredExternal, addr)
}
}
+ h.ExternalAddrs = filteredExternal
- hub := &Hub{
- Host: h,
- DHT: kadDHT,
- Providers: providers,
- KeyRing: kr,
- MeshID: config.MeshName,
- Policy: config.Policy,
- limiter: rate.NewLimiter(rate.Limit(EnrollRateLimit), EnrollBurst),
- ExternalAddrs: filteredExternal,
- AllowedAudiences: config.AllowedAudiences,
- AllowLoopback: config.AllowLoopback,
- logger: golog.Logger("sam-hub"),
- oidcIssuer: config.OIDCIssuer,
- keyRotationInterval: config.KeyRotationInterval,
- keyGracePeriod: config.KeyGracePeriod,
- insecureSkipTLSVerify: config.InsecureSkipTLSVerify,
- }
-
- ps, err := pubsub.NewGossipSub(ctx, h)
+ ps, err := pubsub.NewGossipSub(ctx, hostNode)
if err != nil {
- _ = hub.Close()
- return nil, err
+ return err
}
+ h.PubSub = ps
+
topic, err := ps.Join(api.GossipEvents)
if err != nil {
- _ = hub.Close()
- return nil, err
+ return err
}
+ h.EventTopic = topic
- hub.PubSub = ps
- hub.EventTopic = topic
-
- _, err = relay.New(h, relay.WithACL(&relayACL{hub: hub}))
+ _, err = relay.New(hostNode, relay.WithACL(&relayACL{hub: h}))
if err != nil {
- _ = hub.Close()
- return nil, err
+ return err
}
- h.SetStreamHandler(api.AuthProtocolID, hub.HandleAuthHandshake)
+ hostNode.SetStreamHandler(api.AuthProtocolID, h.HandleAuthHandshake)
- h.Network().Notify(&network.NotifyBundle{
+ hostNode.Network().Notify(&network.NotifyBundle{
DisconnectedF: func(n network.Network, c network.Conn) {
p := c.RemotePeer()
- if len(h.Network().ConnsToPeer(p)) == 0 {
- hub.authenticatedPeers.Delete(p)
+ if len(hostNode.Network().ConnsToPeer(p)) == 0 {
+ h.authenticatedPeers.Delete(p)
}
},
})
- hub.logger.Infof("[OIDC] Trusted issuers: %s", config.OIDCIssuer)
+ h.logger.Infof("[OIDC] Trusted issuers: %s", h.config.OIDCIssuer)
- return hub, nil
+ // Start key rotation if enabled
+ h.StartRotation(ctx)
+
+ // Start bootstrap federation if enabled
+ if len(h.config.ExternalMultiaddrs) > 0 {
+ go h.StartBootstrapFederation(ctx, h.config.ExternalMultiaddrs)
+ }
+
+ return nil
}
// Ready returns the ready status of the Hub.
@@ -287,6 +295,11 @@ func (h *Hub) SetReady(ready bool) {
// Close closes the underlying p2p host and keyring db.
func (h *Hub) Close() error {
var errs []error
+ if h.DHT != nil {
+ if err := h.DHT.Close(); err != nil {
+ errs = append(errs, err)
+ }
+ }
if h.Host != nil {
if err := h.Host.Close(); err != nil {
errs = append(errs, err)
diff --git a/internal/node/enroll.go b/internal/node/enroll.go
index 6dfb6adc..609c8559 100644
--- a/internal/node/enroll.go
+++ b/internal/node/enroll.go
@@ -113,6 +113,10 @@ func (n *SamNode) Enroll(ctx context.Context, hubURL string, jwt string) error {
return fmt.Errorf("received empty biscuit token")
}
+ if len(enrollResp.HubPublicKey) != ed25519.PublicKeySize {
+ return fmt.Errorf("received invalid hub public key size: %d bytes (expected %d)", len(enrollResp.HubPublicKey), ed25519.PublicKeySize)
+ }
+
if err := n.Store.SaveIdentity(enrollResp.BiscuitToken); err != nil {
return fmt.Errorf("failed to save identity: %v", err)
}
diff --git a/internal/node/enroll_test.go b/internal/node/enroll_test.go
index 4f853e5f..a247b2dc 100644
--- a/internal/node/enroll_test.go
+++ b/internal/node/enroll_test.go
@@ -16,9 +16,16 @@ package node
import (
"bytes"
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "strings"
"testing"
+ "time"
+ "github.com/google/sam/api"
"github.com/libp2p/go-libp2p/core/crypto"
+ "google.golang.org/protobuf/proto"
)
func TestGetOrGenerateKey(t *testing.T) {
@@ -48,3 +55,56 @@ func TestGetOrGenerateKey(t *testing.T) {
t.Error("Expected retrieved key to match generated key")
}
}
+
+func TestEnroll_InvalidHubPublicKeySize(t *testing.T) {
+ // 1. Start a fake hub enrollment server
+ invalidKey := []byte("too-short") // Not ed25519.PublicKeySize (32 bytes)
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/register" {
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ }
+ resp := &api.EnrollResponse{
+ BiscuitToken: []byte("mock-token"),
+ Expiration: time.Now().Add(1 * time.Hour).Unix(),
+ HubPublicKey: invalidKey,
+ HubAddresses: []string{"/ip4/127.0.0.1/tcp/4001"},
+ }
+ data, _ := proto.Marshal(resp)
+ w.Header().Set("Content-Type", "application/x-protobuf")
+ w.WriteHeader(http.StatusOK)
+ _, _ = w.Write(data)
+ }))
+ defer srv.Close()
+
+ // 2. Setup mock node options
+ dir := t.TempDir()
+ store, err := NewStore(dir)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = store.Close() }()
+
+ priv, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ node, err := NewSamNode(Options{
+ PrivKey: priv,
+ Store: store,
+ ListenAddrs: []string{"/ip4/127.0.0.1/tcp/0"},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ ctx := context.Background()
+ if err := node.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
+
+ // 3. Call enroll which should fail due to public key validation
+ err = node.Enroll(context.Background(), srv.URL, "dummy-jwt")
+ if err == nil {
+ t.Fatal("Expected Enroll to fail with invalid public key size, but it succeeded")
+ }
+ if !strings.Contains(err.Error(), "received invalid hub public key size") {
+ t.Fatalf("Expected invalid public key size error, got: %v", err)
+ }
+}
diff --git a/internal/node/gate_test.go b/internal/node/gate_test.go
index 13ff255d..da14f49e 100644
--- a/internal/node/gate_test.go
+++ b/internal/node/gate_test.go
@@ -112,7 +112,7 @@ func startBareNode(t *testing.T, ctx context.Context) (*SamNode, func()) {
if err != nil {
t.Fatal(err)
}
- node, err := NewSamNode(ctx, Options{
+ node, err := NewSamNode(Options{
PrivKey: priv,
HubAddrs: nil,
Store: store,
@@ -130,6 +130,9 @@ func startBareNode(t *testing.T, ctx context.Context) (*SamNode, func()) {
if err != nil {
t.Fatal(err)
}
+ if err := node.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
cleanup := func() {
_ = node.Teardown()
diff --git a/internal/node/node.go b/internal/node/node.go
index cae918f1..de1adc9e 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -115,6 +115,7 @@ func (a *nodeRelayACL) AllowConnect(src peer.ID, srcAddr multiaddr.Multiaddr, de
}
type SamNode struct {
+ config Options
Host host.Host
DHT *dht.IpfsDHT
PubSub *pubsub.PubSub
@@ -216,7 +217,8 @@ func resolveAddrIfNeeded(ctx context.Context, addr multiaddr.Multiaddr) ([]multi
}
// NewSamNode creates a new Agent instance secured with the 4-layer pipeline.
-func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
+// NewSamNode initializes options and structures without starting background tasks or network interfaces.
+func NewSamNode(cfg Options) (*SamNode, error) {
cfg.Default()
if err := cfg.Validate(); err != nil {
return nil, err
@@ -228,6 +230,7 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
}
node := &SamNode{
+ config: cfg,
Store: cfg.Store,
trustedKeys: trustedKeys,
peerLastEventTime: make(map[string]int64),
@@ -236,12 +239,10 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
authenticatedHubs: make(map[peer.ID]bool),
LocalPolicy: cfg.NodeConfig,
AllowLoopback: cfg.AllowLoopback,
-
authSuccess: make(chan struct{}),
reprovideTrigger: make(chan struct{}, 1),
logger: golog.Logger("sam-node"),
}
-
node.BiscuitTimeout = cfg.BiscuitTimeout
var err error
@@ -254,12 +255,17 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
return nil, fmt.Errorf("failed to create revocation cache: %w", err)
}
+ return node, nil
+}
+
+// Start initializes the libp2p host, DHT, connects to the hub, and starts runtime components.
+func (n *SamNode) Start(ctx context.Context) error {
// Layer 2: Attach the Bouncer (Gater)
- gater := &nodeConnGate{node: node}
+ gater := &nodeConnGate{node: n}
// Convert Hub multiaddrs to peer.AddrInfo to use as static relays
var staticRelays []peer.AddrInfo
- for _, addr := range cfg.HubAddrs {
+ for _, addr := range n.config.HubAddrs {
resolvedAddrs, err := resolveAddrIfNeeded(ctx, addr)
if err != nil {
resolvedAddrs = []multiaddr.Multiaddr{addr}
@@ -267,8 +273,8 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
for _, resolved := range resolvedAddrs {
if addrInfo, err := peer.AddrInfoFromP2pAddr(resolved); err == nil && addrInfo.ID != "" {
staticRelays = append(staticRelays, *addrInfo)
- if node.HubPeerID == "" {
- node.HubPeerID = addrInfo.ID
+ if n.HubPeerID == "" {
+ n.HubPeerID = addrInfo.ID
}
} else {
logger.Warnf("Failed to parse static relay addr %s: %v", resolved, err)
@@ -279,16 +285,16 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
cm, err := connmgr.NewConnManager(100, 400, connmgr.WithGracePeriod(time.Minute))
if err != nil {
- return nil, fmt.Errorf("failed to create connection manager: %w", err)
+ return fmt.Errorf("failed to create connection manager: %w", err)
}
// Layer 1: Establish FIPS-compliant Transports & NAT Services
opts := []libp2p.Option{
- libp2p.Identity(cfg.PrivKey),
+ libp2p.Identity(n.config.PrivKey),
libp2p.DefaultTransports,
libp2p.Security(libp2ptls.ID, libp2ptls.New),
libp2p.ConnectionGater(gater),
- libp2p.ListenAddrStrings(cfg.ListenAddrs...),
+ libp2p.ListenAddrStrings(n.config.ListenAddrs...),
libp2p.EnableNATService(),
libp2p.EnableAutoNATv2(),
libp2p.ForceReachabilityPrivate(),
@@ -297,7 +303,7 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
libp2p.ConnectionManager(cm),
libp2p.SwarmOpts(swarm.WithDialTimeout(15 * time.Second)),
libp2p.AddrsFactory(func(addrs []multiaddr.Multiaddr) []multiaddr.Multiaddr {
- if cfg.AllowLoopback {
+ if n.config.AllowLoopback {
return addrs
}
var filtered []multiaddr.Multiaddr
@@ -312,13 +318,13 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
// If we have a Hub, configure it as our static fallback relay for NAT hole-punching
if len(staticRelays) > 0 {
- node.currentRelays = staticRelays
+ n.currentRelays = staticRelays
opts = append(opts, libp2p.EnableAutoRelayWithPeerSource(
func(ctx context.Context, numPeers int) <-chan peer.AddrInfo {
logger.Infof("[Relay] AutoRelay called PeerSource for %d peers", numPeers)
- node.mu.Lock()
- currentRelays := node.currentRelays
- node.mu.Unlock()
+ n.mu.Lock()
+ currentRelays := n.currentRelays
+ n.mu.Unlock()
c := make(chan peer.AddrInfo, len(currentRelays))
go func() {
@@ -326,7 +332,7 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
select {
case <-ctx.Done():
logger.Infof("[Relay] PeerSource context done")
- case <-node.authSuccess:
+ case <-n.authSuccess:
logger.Infof("[Relay] Yielding static relays to AutoRelay")
// Shuffle the relays to distribute load evenly across Hubs
shuffled := make([]peer.AddrInfo, len(currentRelays))
@@ -341,22 +347,22 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
}()
return c
},
- autorelay.WithBootDelay(cfg.AutoRelayBootDelay),
- autorelay.WithBackoff(cfg.AutoRelayBackoff),
- autorelay.WithMinInterval(cfg.AutoRelayMinInterval),
+ autorelay.WithBootDelay(n.config.AutoRelayBootDelay),
+ autorelay.WithBackoff(n.config.AutoRelayBackoff),
+ autorelay.WithMinInterval(n.config.AutoRelayMinInterval),
))
}
// If the user explicitly opts in, allow this node to serve as a relay for others
- if cfg.EnableRelay {
+ if n.config.EnableRelay {
logger.Infof("[Relay] Enabling Relay Service")
}
h, err := libp2p.New(opts...)
if err != nil {
- return nil, err
+ return err
}
- node.Host = h
+ n.Host = h
h.Network().Notify(&network.NotifyBundle{
ConnectedF: func(n network.Network, c network.Conn) {
@@ -376,28 +382,28 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
h.Peerstore().AddAddrs(pi.ID, pi.Addrs, peerstore.PermanentAddrTTL)
}
- if cfg.EnableRelay {
+ if n.config.EnableRelay {
logger.Infof("[Relay] Enabling Relay Service with ACL")
- _, err = relay.New(h, relay.WithACL(&nodeRelayACL{node: node}))
+ _, err = relay.New(h, relay.WithACL(&nodeRelayACL{node: n}))
if err != nil {
- return nil, err
+ return err
}
}
// Initialize Rendezvous (DHT Client)
kdht, err := dht.New(ctx, h, dht.Mode(dht.ModeAuto), dht.ProtocolPrefix("/sam"))
if err != nil {
- return nil, err
+ return err
}
- node.DHT = kdht
+ n.DHT = kdht
- node.services = NewServiceRegistry(node.DHT)
+ n.services = NewServiceRegistry(n.DHT)
var authenticated bool
var fatalAuthErr error
- for _, addr := range cfg.HubAddrs {
- if err := node.ConnectAndAuthWithHub(ctx, addr); err != nil {
+ for _, addr := range n.config.HubAddrs {
+ if err := n.ConnectAndAuthWithHub(ctx, addr); err != nil {
logger.Warnf("[AuthN] Failed to bootstrap and auth with hub %s: %v", addr, err)
if errors.Is(err, ErrFatalAuth) {
fatalAuthErr = err
@@ -407,16 +413,16 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
}
}
- if len(cfg.HubAddrs) > 0 && !authenticated {
+ if len(n.config.HubAddrs) > 0 && !authenticated {
if fatalAuthErr != nil {
- return nil, fmt.Errorf("fatal auth failure: %w", fatalAuthErr)
+ return fmt.Errorf("fatal auth failure: %w", fatalAuthErr)
}
- return nil, fmt.Errorf("failed to authenticate with any hub: all connection attempts failed")
+ return fmt.Errorf("failed to authenticate with any hub: all connection attempts failed")
}
if authenticated {
logger.Infof("[DHT] Bootstrapping DHT with connected hub...")
- if err := node.DHT.Bootstrap(ctx); err != nil {
+ if err := n.DHT.Bootstrap(ctx); err != nil {
logger.Warnf("[DHT] Failed to trigger DHT bootstrap: %v", err)
}
}
@@ -424,9 +430,9 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
// Initialize Gossipsub for Hub Events
ps, err := pubsub.NewGossipSub(ctx, h)
if err != nil {
- return nil, err
+ return err
}
- node.PubSub = ps
+ n.PubSub = ps
// Subscribe to local address updates to reprovide services and log
sub, err := h.EventBus().Subscribe(new(event.EvtLocalAddressesUpdated))
@@ -457,7 +463,7 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
go func() {
time.Sleep(2 * time.Second) // Small debounce
select {
- case node.reprovideTrigger <- struct{}{}:
+ case n.reprovideTrigger <- struct{}{}:
default:
}
}()
@@ -467,38 +473,38 @@ func NewSamNode(ctx context.Context, cfg Options) (*SamNode, error) {
}
// Listen for Network Evictions/Revocations from the Hub
- go node.listenForHubEvents(ctx)
+ go n.listenForHubEvents(ctx)
- interval, err := time.ParseDuration(cfg.DiscoveryInterval)
+ interval, err := time.ParseDuration(n.config.DiscoveryInterval)
if err != nil {
- logger.Warnf("[Discovery] Invalid discovery interval '%s', using default %s: %v", cfg.DiscoveryInterval, DefaultDiscoveryInterval, err)
+ logger.Warnf("[Discovery] Invalid discovery interval '%s', using default %s: %v", n.config.DiscoveryInterval, DefaultDiscoveryInterval, err)
interval, _ = time.ParseDuration(DefaultDiscoveryInterval)
}
// Start DHT Discovery
- go node.startDiscovery(ctx, cfg.MeshID, interval)
+ go n.startDiscovery(ctx, n.config.MeshID, interval)
// Layer 3: Open the Lobby Door (Auth Protocol is bypassed by Layer 4)
- node.Host.SetStreamHandler(api.AuthProtocolID, node.HandleAuthHandshake)
+ n.Host.SetStreamHandler(api.AuthProtocolID, n.HandleAuthHandshake)
// Layer 3: Wire up MCP handler wrapped in middleware
- node.Host.SetStreamHandler(api.MCPProtocolID, node.WithBiscuitAuth(node.HandleMCPStream))
+ n.Host.SetStreamHandler(api.MCPProtocolID, n.WithBiscuitAuth(n.HandleMCPStream))
// Start key pruning
- node.startKeyPruning(ctx, cfg.KeyGracePeriod)
+ n.startKeyPruning(ctx, n.config.KeyGracePeriod)
// Start Ingress HTTP Server
- if err := node.StartIngressServer(ctx); err != nil {
- return nil, fmt.Errorf("failed to start ingress server: %w", err)
+ if err := n.StartIngressServer(ctx); err != nil {
+ return fmt.Errorf("failed to start ingress server: %w", err)
}
// Start connection monitor
- node.startConnectionMonitor(ctx, cfg.MonitorBootstrap, cfg.MonitorInterval, 3)
+ n.startConnectionMonitor(ctx, n.config.MonitorBootstrap, n.config.MonitorInterval, 3)
// Periodically and on-demand reprovide registered services to the DHT
- node.startReprovideLoop(ctx, ReprovideInterval)
+ n.startReprovideLoop(ctx, ReprovideInterval)
- return node, nil
+ return nil
}
func (n *SamNode) startReprovideLoop(ctx context.Context, interval time.Duration) {
@@ -1232,10 +1238,18 @@ func (n *SamNode) Teardown() error {
if n.services != nil {
n.services.TeardownAll()
}
+ var errs []error
+ if n.DHT != nil {
+ if err := n.DHT.Close(); err != nil {
+ errs = append(errs, err)
+ }
+ }
if n.Host != nil {
- return n.Host.Close()
+ if err := n.Host.Close(); err != nil {
+ errs = append(errs, err)
+ }
}
- return nil
+ return errors.Join(errs...)
}
func (n *SamNode) IsServiceRegistered(serviceName string) bool {
diff --git a/internal/node/node_test.go b/internal/node/node_test.go
index 2763eea4..0fb57c31 100644
--- a/internal/node/node_test.go
+++ b/internal/node/node_test.go
@@ -100,7 +100,7 @@ func TestConnectionMonitor_CrashesAfterFailures(t *testing.T) {
if os.Getenv("BE_CRASHER_MONITOR") == "1" {
priv, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
store, _ := NewStore(t.TempDir())
- node, err := NewSamNode(context.Background(), Options{
+ node, err := NewSamNode(Options{
PrivKey: priv,
HubAddrs: nil,
Store: store,
@@ -117,6 +117,9 @@ func TestConnectionMonitor_CrashesAfterFailures(t *testing.T) {
if err != nil {
os.Exit(0) // Ignore NewSamNode errors for this crasher
}
+ if err := node.Start(context.Background()); err != nil {
+ os.Exit(0)
+ }
// Use very short durations
node.startConnectionMonitor(context.Background(), 10*time.Millisecond, 10*time.Millisecond, 3)
@@ -133,3 +136,29 @@ func TestConnectionMonitor_CrashesAfterFailures(t *testing.T) {
}
t.Fatalf("process ran with err %v, want exit status 1 (fatal crash)", err)
}
+
+func TestNewSamNode_Validation(t *testing.T) {
+ priv, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ store, _ := NewStore(t.TempDir())
+ defer func() { _ = store.Close() }()
+
+ t.Run("nil PrivKey", func(t *testing.T) {
+ _, err := NewSamNode(Options{
+ PrivKey: nil,
+ Store: store,
+ })
+ if err == nil || err.Error() != "private key is required" {
+ t.Errorf("expected 'private key is required' error, got: %v", err)
+ }
+ })
+
+ t.Run("nil Store", func(t *testing.T) {
+ _, err := NewSamNode(Options{
+ PrivKey: priv,
+ Store: nil,
+ })
+ if err == nil || err.Error() != "store is required" {
+ t.Errorf("expected 'store is required' error, got: %v", err)
+ }
+ })
+}
diff --git a/internal/node/proxy_test.go b/internal/node/proxy_test.go
index 93afd26f..f86776f2 100644
--- a/internal/node/proxy_test.go
+++ b/internal/node/proxy_test.go
@@ -55,7 +55,7 @@ func TestDatapathIntegration(t *testing.T) {
// Pre-populate stores with dummy keys to avoid enrollment failure if required
// For this test, we assume we can run without full enrollment if we bypass AuthHandler
- nodeA, err := NewSamNode(ctx, Options{
+ nodeA, err := NewSamNode(Options{
PrivKey: privA,
HubAddrs: nil,
Store: storeA,
@@ -73,13 +73,16 @@ func TestDatapathIntegration(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeA.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() {
if err := nodeA.Host.Close(); err != nil {
t.Logf("failed to close nodeA host: %v", err)
}
}()
- nodeB, err := NewSamNode(ctx, Options{
+ nodeB, err := NewSamNode(Options{
PrivKey: privB,
HubAddrs: nil,
Store: storeB,
@@ -97,6 +100,9 @@ func TestDatapathIntegration(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeB.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() {
if err := nodeB.Host.Close(); err != nil {
t.Logf("failed to close nodeB host: %v", err)
@@ -253,7 +259,7 @@ func TestDatapathIntegration_Unauthenticated(t *testing.T) {
}
defer func() { _ = storeB.Close() }()
- nodeA, err := NewSamNode(ctx, Options{
+ nodeA, err := NewSamNode(Options{
PrivKey: privA,
HubAddrs: nil,
Store: storeA,
@@ -271,13 +277,16 @@ func TestDatapathIntegration_Unauthenticated(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeA.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() {
if err := nodeA.Host.Close(); err != nil {
t.Logf("failed to close nodeA host: %v", err)
}
}()
- nodeB, err := NewSamNode(ctx, Options{
+ nodeB, err := NewSamNode(Options{
PrivKey: privB,
HubAddrs: nil,
Store: storeB,
@@ -295,6 +304,9 @@ func TestDatapathIntegration_Unauthenticated(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeB.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() {
if err := nodeB.Host.Close(); err != nil {
t.Logf("failed to close nodeB host: %v", err)
@@ -396,7 +408,7 @@ func TestStdioDatapathIntegration(t *testing.T) {
}
defer func() { _ = storeB.Close() }()
- nodeA, err := NewSamNode(ctx, Options{
+ nodeA, err := NewSamNode(Options{
PrivKey: privA,
HubAddrs: nil,
Store: storeA,
@@ -414,9 +426,12 @@ func TestStdioDatapathIntegration(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeA.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() { _ = nodeA.Host.Close() }()
- nodeB, err := NewSamNode(ctx, Options{
+ nodeB, err := NewSamNode(Options{
PrivKey: privB,
HubAddrs: nil,
Store: storeB,
@@ -434,6 +449,9 @@ func TestStdioDatapathIntegration(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeB.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() { _ = nodeB.Host.Close() }()
// Setup identity for Node B (the caller proxy) and trust it on Node A
@@ -580,7 +598,7 @@ func TestDatapathHeadersAndRoutingTable(t *testing.T) {
}
defer func() { _ = storeB.Close() }()
- nodeA, err := NewSamNode(ctx, Options{
+ nodeA, err := NewSamNode(Options{
PrivKey: privA,
HubAddrs: nil,
Store: storeA,
@@ -598,13 +616,16 @@ func TestDatapathHeadersAndRoutingTable(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeA.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() {
if err := nodeA.Host.Close(); err != nil {
t.Logf("failed to close nodeA host: %v", err)
}
}()
- nodeB, err := NewSamNode(ctx, Options{
+ nodeB, err := NewSamNode(Options{
PrivKey: privB,
HubAddrs: nil,
Store: storeB,
@@ -622,6 +643,9 @@ func TestDatapathHeadersAndRoutingTable(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if err := nodeB.Start(ctx); err != nil {
+ t.Fatal(err)
+ }
defer func() {
if err := nodeB.Host.Close(); err != nil {
t.Logf("failed to close nodeB host: %v", err)
diff --git a/internal/node/sidecar.go b/internal/node/sidecar.go
index dedbeaf8..12ee3897 100644
--- a/internal/node/sidecar.go
+++ b/internal/node/sidecar.go
@@ -36,7 +36,7 @@ import (
"google.golang.org/protobuf/encoding/protojson"
)
-func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile string) error {
+func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile string) (*http.Server, error) {
mux := http.NewServeMux()
// Public endpoints
@@ -67,14 +67,15 @@ func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile st
listener, err := net.Listen("tcp", addr)
if err != nil {
- return fmt.Errorf("failed to listen on %s: %w", addr, err)
+ return nil, fmt.Errorf("failed to listen on %s: %w", addr, err)
}
actualAddr := listener.Addr().String()
node.BoundHTTPAddr = actualAddr
if (certFile != "") != (keyFile != "") {
- return fmt.Errorf("both --tls-cert and --tls-key must be provided to enable TLS")
+ _ = listener.Close()
+ return nil, fmt.Errorf("both --tls-cert and --tls-key must be provided to enable TLS")
}
if certFile != "" && keyFile != "" {
@@ -83,7 +84,8 @@ func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile st
if caFile != "" {
caCert, err := os.ReadFile(caFile)
if err != nil {
- return fmt.Errorf("failed to read CA cert: %w", err)
+ _ = listener.Close()
+ return nil, fmt.Errorf("failed to read CA cert: %w", err)
}
caCertPool := x509.NewCertPool()
caCertPool.AppendCertsFromPEM(caCert)
@@ -93,7 +95,8 @@ func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile st
}
if !isMTLS && token == "" {
- return fmt.Errorf("token is mandatory when not using mTLS")
+ _ = listener.Close()
+ return nil, fmt.Errorf("token is mandatory when not using mTLS")
}
server.TLSConfig = tlsConfig
@@ -105,7 +108,8 @@ func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile st
}()
} else {
if token == "" {
- return fmt.Errorf("token is mandatory when not using mTLS")
+ _ = listener.Close()
+ return nil, fmt.Errorf("token is mandatory when not using mTLS")
}
logger.Infof("Starting MCP server on TCP address %s", actualAddr)
go func() {
@@ -114,10 +118,10 @@ func StartSidecarServer(node *SamNode, addr, token, certFile, keyFile, caFile st
}
}()
}
- return nil
+ return server, nil
}
-func StartUnauthSidecarServer(hubURL, addr, certFile, keyFile string) error {
+func StartUnauthSidecarServer(hubURL, addr, certFile, keyFile string) (*http.Server, error) {
mux := http.NewServeMux()
// Public endpoints
@@ -134,13 +138,14 @@ func StartUnauthSidecarServer(hubURL, addr, certFile, keyFile string) error {
listener, err := net.Listen("tcp", addr)
if err != nil {
- return fmt.Errorf("failed to listen on %s: %w", addr, err)
+ return nil, fmt.Errorf("failed to listen on %s: %w", addr, err)
}
actualAddr := listener.Addr().String()
if (certFile != "") != (keyFile != "") {
- return fmt.Errorf("both --tls-cert and --tls-key must be provided to enable TLS")
+ _ = listener.Close()
+ return nil, fmt.Errorf("both --tls-cert and --tls-key must be provided to enable TLS")
}
if certFile != "" && keyFile != "" {
@@ -158,7 +163,7 @@ func StartUnauthSidecarServer(hubURL, addr, certFile, keyFile string) error {
}
}()
}
- return nil
+ return server, nil
}
func handleHealthz(w http.ResponseWriter, r *http.Request) {
diff --git a/internal/node/sidecar_test.go b/internal/node/sidecar_test.go
index 92387e10..aba2c3e2 100644
--- a/internal/node/sidecar_test.go
+++ b/internal/node/sidecar_test.go
@@ -105,10 +105,11 @@ func TestSidecarServerAuthEnforcement(t *testing.T) {
token := "test-token"
// Start sidecar on an ephemeral port
- err := StartSidecarServer(node, "127.0.0.1:0", token, "", "", "")
+ sidecarSrv, err := StartSidecarServer(node, "127.0.0.1:0", token, "", "", "")
if err != nil {
t.Fatalf("Failed to start sidecar server: %v", err)
}
+ defer func() { _ = sidecarSrv.Close() }()
baseURL := "http://" + node.BoundHTTPAddr
client := &http.Client{Timeout: 2 * time.Second}
@@ -524,7 +525,7 @@ func TestStartSidecarServer_TokenMandatory(t *testing.T) {
node := &SamNode{BiscuitTimeout: 500 * time.Millisecond}
// Test case: No token, no TLS
- err := StartSidecarServer(node, "127.0.0.1:0", "", "", "", "")
+ _, err := StartSidecarServer(node, "127.0.0.1:0", "", "", "", "")
if err == nil {
t.Fatal("Expected StartSidecarServer to fail without token and TLS, but it succeeded")
}
@@ -533,8 +534,10 @@ func TestStartSidecarServer_TokenMandatory(t *testing.T) {
}
// Test case: Token provided, should not fail immediately
- err = StartSidecarServer(node, "127.0.0.1:0", "some-token", "", "", "")
- if err != nil {
+ sidecarSrv, err := StartSidecarServer(node, "127.0.0.1:0", "some-token", "", "", "")
+ if err == nil {
+ defer func() { _ = sidecarSrv.Close() }()
+ } else {
if strings.Contains(err.Error(), "token is mandatory when not using mTLS") {
t.Fatalf("Did not expect 'token is mandatory' error when token is provided, got: %v", err)
}
diff --git a/internal/node/static_service_test.go b/internal/node/static_service_test.go
index 13872c4c..202ed303 100644
--- a/internal/node/static_service_test.go
+++ b/internal/node/static_service_test.go
@@ -64,7 +64,7 @@ func startMockLibp2pHub(t *testing.T) (peer.ID, string) {
resp := &api.EnrollResponse{
BiscuitToken: []byte("mock-biscuit-token"),
- HubPublicKey: []byte("mock-hub-pub-key"),
+ HubPublicKey: make([]byte, 32),
HubAddresses: []string{h.Addrs()[0].String() + "/p2p/" + h.ID().String()},
}
data, err := proto.Marshal(resp)
@@ -106,7 +106,7 @@ func TestStaticServiceRegistrationRequiresConnection(t *testing.T) {
}
// 4. Create Node with empty hub addrs initially
- node, err := NewSamNode(context.Background(), Options{
+ node, err := NewSamNode(Options{
PrivKey: priv,
HubAddrs: []multiaddr.Multiaddr{},
Store: store,
@@ -123,6 +123,10 @@ func TestStaticServiceRegistrationRequiresConnection(t *testing.T) {
if err != nil {
t.Fatalf("failed to create node: %v", err)
}
+ ctx := context.Background()
+ if err := node.Start(ctx); err != nil {
+ t.Fatalf("failed to start node: %v", err)
+ }
defer func() {
if err := node.Host.Close(); err != nil {
t.Errorf("failed to close node host: %v", err)
@@ -143,7 +147,6 @@ func TestStaticServiceRegistrationRequiresConnection(t *testing.T) {
},
}
- ctx := context.Background()
err = node.RegisterStaticServices(ctx, services)
if err == nil {
t.Fatal("Expected RegisterStaticServices to fail before connecting to hub, but it succeeded")
@@ -188,7 +191,7 @@ func TestStaticServiceRegistrationCommandFailure(t *testing.T) {
}
// 4. Create Node with empty hub addrs initially
- node, err := NewSamNode(context.Background(), Options{
+ node, err := NewSamNode(Options{
PrivKey: priv,
HubAddrs: []multiaddr.Multiaddr{},
Store: store,
@@ -205,6 +208,10 @@ func TestStaticServiceRegistrationCommandFailure(t *testing.T) {
if err != nil {
t.Fatalf("failed to create node: %v", err)
}
+ ctx := context.Background()
+ if err := node.Start(ctx); err != nil {
+ t.Fatalf("failed to start node: %v", err)
+ }
defer func() {
if err := node.Host.Close(); err != nil {
t.Errorf("failed to close node host: %v", err)
@@ -212,7 +219,6 @@ func TestStaticServiceRegistrationCommandFailure(t *testing.T) {
}()
// 5. Enroll and connect to hub (which sets up DHT and hub connection)
- ctx := context.Background()
err = node.Enroll(ctx, hubURL, "dummy-jwt")
if err != nil {
t.Fatalf("failed to enroll: %v", err)