Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
refactor and add test coverage
Antonio Ojea3c9bbdb86259
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.goindex 32d0945f..1b4af22c 100644--- a/cmd/sam-hub/main.go+++ b/cmd/sam-hub/main.go@@ -38,6 +38,7 @@ import (pubsub "github.com/libp2p/go-libp2p-pubsub""github.com/libp2p/go-libp2p/core/host""github.com/libp2p/go-libp2p/core/network"+ "github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/p2p/net/connmgr""github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls"@@ -62,6 +63,19 @@ const (LowWaterMark = 100HighWaterMark = 400ConnGracePeriod = 1 * time.Minute++ // Biscuit fact names+ FactExpiration = "expiration"+ FactNode = "node"+ FactClientPeerID = "client_peer_id"+ FactGroup = "group"++ // Defaults+ DefaultOIDCIssuer = "https://accounts.google.com"+ DefaultMeshName = "public-mesh"+ DefaultPolicyFile = "policies.yaml"+ DefaultKeysDBPath = "keys.db"+ DefaultBindAddress = ":9090")var isHubReady atomic.Bool@@ -239,22 +253,105 @@ func (h *Hub) handleEnroll(s network.Stream) {return}- // Parse JWT unverified to get issuer and audience- jwtParser := jwt.Parser{}- jwtToken, _, err := jwtParser.ParseUnverified(req.Jwt, jwt.MapClaims{})+ claims, token, err := h.parseAndVerifyJWT(context.Background(), req.Jwt, remotePeer)if err != nil {- logger.Errorw("Failed to parse JWT in enrollment", "peer_id", remotePeer, "error", err)+ logger.Errorw("JWT verification failed", "peer_id", remotePeer, "error", err)samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to parse JWT", 0, nil, nil)+ h.sendEnrollResponse(s, nil, err.Error(), 0, nil, nil)return}- claims, ok := jwtToken.Claims.(jwt.MapClaims)- if !ok {- logger.Warnw("Invalid JWT claims in enrollment", "peer_id", remotePeer)++ biscuitData, err := h.mintBiscuitToken(claims, token, remotePeer)+ if err != nil {+ logger.Errorw("Biscuit minting failed", "peer_id", remotePeer, "error", err)samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Invalid JWT claims", 0, nil, nil)+ h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)+ return+ }++ h.gater.mu.Lock()+ // Update active nodes gauge if this is a new node+ if !h.gater.authenticated[remotePeer] {+ samHubActiveNodes.Inc()+ }+ h.gater.authenticated[remotePeer] = true+ delete(h.gater.pending, remotePeer)++ // Collect authenticated peers+ var knownPeers []string+ for p := range h.gater.authenticated {+ knownPeers = append(knownPeers, p.String())+ }+ h.gater.mu.Unlock()++ policies := []string{+ `allow if operation($op)`,+ }++ h.sendEnrollResponse(s, biscuitData, "", token.Expiry.Unix(), knownPeers, policies)+ logger.Infow("Successfully enrolled peer", "peer_id", remotePeer)+ samHubEnrollmentTotal.WithLabelValues("success").Inc()++ // Publish JOIN event+ event := &api.MeshEvent{+ Type: api.MeshEvent_JOIN,+ PeerId: remotePeer.String(),+ Timestamp: time.Now().Unix(),+ }+ if err := h.signEvent(event); err != nil {+ logger.Errorw("Failed to sign mesh event", "peer_id", remotePeer, "error", err)+ } else {+ eventData, err := proto.Marshal(event)+ if err != nil {+ logger.Errorw("Failed to marshal mesh event", "peer_id", remotePeer, "error", err)+ } else {+ if err := h.EventTopic.Publish(context.Background(), eventData); err != nil {+ logger.Errorw("Failed to publish mesh event", "peer_id", remotePeer, "error", err)+ } else {+ logger.Infow("Published JOIN event", "peer_id", remotePeer)+ samHubMeshEventsTotal.WithLabelValues("JOIN").Inc()+ }+ }+ }+}++func (h *Hub) sendEnrollResponse(s network.Stream, biscuitToken []byte, errMsg string, expiration int64, knownPeers []string, policies []string) {+ var hubAddrs []string+ for _, addr := range h.Host.Addrs() {+ hubAddrs = append(hubAddrs, addr.String()+"/p2p/"+h.Host.ID().String())+ }++ pubKey := h.KeyRing.GetCurrentPublicKey()++ resp := &api.EnrollResponse{+ BiscuitToken: biscuitToken,+ ErrorMessage: errMsg,+ HubPublicKey: pubKey,+ HubAddresses: hubAddrs,+ Expiration: expiration,+ KnownPeers: knownPeers,+ }+ data, err := proto.Marshal(resp)+ if err != nil {+ logger.Errorf("[Enroll] Failed to marshal response: %v", err)return}+ writer := msgio.NewVarintWriter(s)+ if err := writer.WriteMsg(data); err != nil {+ logger.Errorf("[Enroll] Failed to write response: %v", err)+ }+}++func (h *Hub) parseAndVerifyJWT(ctx context.Context, jwtStr string, remotePeer peer.ID) (jwt.MapClaims, *oidc.IDToken, error) {+ jwtParser := jwt.Parser{}+ jwtToken, _, err := jwtParser.ParseUnverified(jwtStr, jwt.MapClaims{})+ if err != nil {+ return nil, nil, fmt.Errorf("failed to parse JWT: %w", err)+ }+ claims, ok := jwtToken.Claims.(jwt.MapClaims)+ if !ok {+ return nil, nil, fmt.Errorf("invalid JWT claims")+ }iss, _ := claims["iss"].(string)var aud string@@ -268,47 +365,34 @@ func (h *Hub) handleEnroll(s network.Stream) {}if aud == "" {- logger.Warnw("Missing aud claim in enrollment", "peer_id", remotePeer)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Missing aud claim", 0, nil, nil)- return+ return nil, nil, fmt.Errorf("missing aud claim")}alg, ok := jwtToken.Header["alg"].(string)if !ok || alg == "" {- logger.Warnw("Missing alg header in enrollment", "peer_id", remotePeer)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Missing alg header", 0, nil, nil)- return+ return nil, nil, fmt.Errorf("missing alg header")}provider, ok := h.Providers[iss]if !ok {- logger.Warnw("Unknown issuer in enrollment", "peer_id", remotePeer, "issuer", iss)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, fmt.Sprintf("Unknown issuer: %s", iss), 0, nil, nil)- return+ return nil, nil, fmt.Errorf("unknown issuer: %s", iss)}verifier := provider.Verifier(&oidc.Config{ClientID: clientID})- token, err := verifier.Verify(context.Background(), req.Jwt)+ token, err := verifier.Verify(ctx, jwtStr)if err != nil {- logger.Errorw("JWT validation failed in enrollment", "peer_id", remotePeer, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, fmt.Sprintf("JWT validation failed: %v", err), 0, nil, nil)- return+ return nil, nil, fmt.Errorf("JWT validation failed: %w", err)}- // Strictly enforce aud and alg after verificationif alg == "none" {- logger.Warnw("Invalid alg claim in enrollment", "peer_id", remotePeer, "alg", alg)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Invalid alg claim", 0, nil, nil)- return+ return nil, nil, fmt.Errorf("invalid alg claim")}- logger.Infow("JWT validated", "peer_id", remotePeer, "aud", aud, "alg", alg)+ return claims, token, nil+}++func (h *Hub) mintBiscuitToken(claims jwt.MapClaims, token *oidc.IDToken, remotePeer peer.ID) ([]byte, error) {var roles []stringif rolesAny, ok := claims["roles"].([]any); ok {for _, r := range rolesAny {@@ -321,44 +405,32 @@ func (h *Hub) handleEnroll(s network.Stream) {builder := biscuit.NewBuilder(h.KeyRing.GetCurrentKey())if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{- Name: "expiration",+ Name: FactExpiration,IDs: []biscuit.Term{biscuit.Date(token.Expiry)},}}); err != nil {- logger.Errorw("Failed to add expiration fact to biscuit", "peer_id", remotePeer, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)- return+ return nil, fmt.Errorf("failed to add expiration fact: %w", err)}if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{- Name: "node",+ Name: FactNode,IDs: []biscuit.Term{biscuit.String(remotePeer.String())},}}); err != nil {- logger.Errorw("Failed to add node fact to biscuit", "peer_id", remotePeer, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)- return+ return nil, fmt.Errorf("failed to add node fact: %w", err)}if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{- Name: "client_peer_id",+ Name: FactClientPeerID,IDs: []biscuit.Term{biscuit.String(remotePeer.String())},}}); err != nil {- logger.Errorw("Failed to add client_peer_id fact to biscuit", "peer_id", remotePeer, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)- return+ return nil, fmt.Errorf("failed to add client_peer_id fact: %w", err)}for _, role := range roles {if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{- Name: "group",+ Name: FactGroup,IDs: []biscuit.Term{biscuit.String(role)},}}); err != nil {- logger.Errorw("Failed to add group fact to biscuit", "peer_id", remotePeer, "role", role, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)- return+ return nil, fmt.Errorf("failed to add group fact: %w", err)}if h.Policy != nil {@@ -406,91 +478,15 @@ func (h *Hub) handleEnroll(s network.Stream) {t, err := builder.Build()if err != nil {- logger.Errorw("Failed to build biscuit", "peer_id", remotePeer, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to build biscuit", 0, nil, nil)- return+ return nil, fmt.Errorf("failed to build biscuit: %w", err)}biscuitData, err := t.Serialize()if err != nil {- logger.Errorw("Failed to serialize biscuit", "peer_id", remotePeer, "error", err)- samHubEnrollmentTotal.WithLabelValues("failed").Inc()- h.sendEnrollResponse(s, nil, "Failed to serialize biscuit", 0, nil, nil)- return- }-- h.gater.mu.Lock()- // Update active nodes gauge if this is a new node- if !h.gater.authenticated[remotePeer] {- samHubActiveNodes.Inc()- }- h.gater.authenticated[remotePeer] = true- delete(h.gater.pending, remotePeer)-- // Collect authenticated peers- var knownPeers []string- for p := range h.gater.authenticated {- knownPeers = append(knownPeers, p.String())+ return nil, fmt.Errorf("failed to serialize biscuit: %w", err)}- h.gater.mu.Unlock()- policies := []string{- `allow if operation($op)`,- }-- h.sendEnrollResponse(s, biscuitData, "", token.Expiry.Unix(), knownPeers, policies)- logger.Infow("Successfully enrolled peer", "peer_id", remotePeer)- samHubEnrollmentTotal.WithLabelValues("success").Inc()-- // Publish JOIN event- event := &api.MeshEvent{- Type: api.MeshEvent_JOIN,- PeerId: remotePeer.String(),- Timestamp: time.Now().Unix(),- }- if err := h.signEvent(event); err != nil {- logger.Errorw("Failed to sign mesh event", "peer_id", remotePeer, "error", err)- } else {- eventData, err := proto.Marshal(event)- if err != nil {- logger.Errorw("Failed to marshal mesh event", "peer_id", remotePeer, "error", err)- } else {- if err := h.EventTopic.Publish(context.Background(), eventData); err != nil {- logger.Errorw("Failed to publish mesh event", "peer_id", remotePeer, "error", err)- } else {- logger.Infow("Published JOIN event", "peer_id", remotePeer)- samHubMeshEventsTotal.WithLabelValues("JOIN").Inc()- }- }- }-}--func (h *Hub) sendEnrollResponse(s network.Stream, biscuitToken []byte, errMsg string, expiration int64, knownPeers []string, policies []string) {- var hubAddrs []string- for _, addr := range h.Host.Addrs() {- hubAddrs = append(hubAddrs, addr.String()+"/p2p/"+h.Host.ID().String())- }-- pubKey := h.KeyRing.GetCurrentPublicKey()-- resp := &api.EnrollResponse{- BiscuitToken: biscuitToken,- ErrorMessage: errMsg,- HubPublicKey: pubKey,- HubAddresses: hubAddrs,- Expiration: expiration,- KnownPeers: knownPeers,- }- data, err := proto.Marshal(resp)- if err != nil {- logger.Errorf("[Enroll] Failed to marshal response: %v", err)- return- }- writer := msgio.NewVarintWriter(s)- if err := writer.WriteMsg(data); err != nil {- logger.Errorf("[Enroll] Failed to write response: %v", err)- }+ return biscuitData, nil}// startWatchdog periodically checks for peers that have connected but not completed OIDC@@ -651,20 +647,20 @@ func main() {defIssuer := os.Getenv("SAM_OIDC_ISSUER")if defIssuer == "" {- defIssuer = "https://accounts.google.com"+ defIssuer = DefaultOIDCIssuer}rootCmd.Flags().StringVar(&oidcIssuer, "issuer", defIssuer, "OIDC Issuer URL")rootCmd.Flags().StringVar(&clientID, "client-id", os.Getenv("SAM_OIDC_ID"), "OIDC Client ID")rootCmd.Flags().StringVar(&biscuitHex, "key", os.Getenv("SAM_HUB_KEY"), "Hub Private Key (32-byte Hex)")rootCmd.Flags().StringSliceVar(&listenAddrs, "listen", []string{"/ip4/0.0.0.0/udp/8080/quic-v1", "/ip4/0.0.0.0/tcp/8080"}, "libp2p Listen Addrs")- rootCmd.Flags().StringVar(&meshName, "mesh", "public-mesh", "Mesh federation name")+ rootCmd.Flags().StringVar(&meshName, "mesh", DefaultMeshName, "Mesh federation name")rootCmd.Flags().BoolVar(&insecureSkipTLSVerify, "insecure-skip-tls-verify", false, "Skip TLS verification for OIDC issuers")rootCmd.Flags().StringVar(&logLevel, "log-level", "info", "Log level (debug, info, warn, error)")- rootCmd.Flags().StringVar(&policyFile, "policy-file", "policies.yaml", "Path to policies.yaml")+ rootCmd.Flags().StringVar(&policyFile, "policy-file", DefaultPolicyFile, "Path to policies.yaml")rootCmd.Flags().DurationVar(&keyRotationInterval, "key-rotation-interval", 0, "Key rotation interval (e.g. 12h). 0 disables rotation.")rootCmd.Flags().DurationVar(&keyGracePeriod, "key-grace-period", 24*time.Hour, "Key grace period for old keys (e.g. 24h).")- rootCmd.Flags().StringVar(&keysDBPath, "keys-db", "keys.db", "Path to BoltDB file for keys")- rootCmd.PersistentFlags().StringVar(&bindAddress, "bind-address", ":9090", "Address to listen on for HTTP/HTTPS service")+ rootCmd.Flags().StringVar(&keysDBPath, "keys-db", DefaultKeysDBPath, "Path to BoltDB file for keys")+ rootCmd.PersistentFlags().StringVar(&bindAddress, "bind-address", DefaultBindAddress, "Address to listen on for HTTP/HTTPS service")rootCmd.PersistentFlags().StringVar(&adminToken, "admin-token", "", "Secret token for authorizing admin requests")rootCmd.PersistentFlags().StringVar(&tlsCertFile, "tls-cert-file", "", "Path to TLS certificate for the server")rootCmd.PersistentFlags().StringVar(&tlsKeyFile, "tls-key-file", "", "Path to TLS private key for the server")diff --git a/cmd/sam-hub/main_test.go b/cmd/sam-hub/main_test.gonew file mode 100644index 00000000..0974440d--- /dev/null+++ b/cmd/sam-hub/main_test.go@@ -0,0 +1,80 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package main++import (+ "path/filepath"+ "testing"+ "time"++ "github.com/coreos/go-oidc/v3/oidc"+ "github.com/golang-jwt/jwt/v5"+ "github.com/google/sam/api"+ "github.com/libp2p/go-libp2p/core/crypto"+ "github.com/libp2p/go-libp2p/core/peer"+)++func TestMintBiscuitToken(t *testing.T) {+ dir := t.TempDir()+ dbPath := filepath.Join(dir, "test.db")++ kr, err := NewKeyRing(dbPath, 24*time.Hour, nil)+ if err != nil {+ t.Fatal(err)+ }+ defer func() { _ = kr.Close() }()++ hub := &Hub{+ KeyRing: kr,+ Policy: &api.PolicyConfig{+ Roles: map[string]api.RolePolicy{+ "admin": {+ MCP: api.MCPPolicy{+ AllowedTools: []string{"read", "write"},+ },+ Network: api.NetworkPolicy{+ AllowedTargets: []string{"target1"},+ },+ },+ },+ },+ }++ claims := jwt.MapClaims{+ "roles": []any{"admin"},+ }++ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)+ if err != nil {+ t.Fatal(err)+ }+ dummyPeer, err := peer.IDFromPrivateKey(priv)+ if err != nil {+ t.Fatal(err)+ }++ token := &oidc.IDToken{+ Expiry: time.Now().Add(1 * time.Hour),+ }++ biscuitData, err := hub.mintBiscuitToken(claims, token, dummyPeer)+ if err != nil {+ t.Fatal(err)+ }++ if len(biscuitData) == 0 {+ t.Error("Expected non-empty biscuit data")+ }+}diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex ac3472dd..19386b4b 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -37,6 +37,18 @@ import ("google.golang.org/protobuf/proto")+const (+ DefaultMeshName = "public-mesh"+ DefaultDiscoveryInterval = "2s"+ DefaultHubURL = "http://localhost:8080"+ DefaultLocalPolicyFile = "local_policy.yaml"++ // Renewal timing defaults+ DefaultRenewalFallback = 50 * time.Minute+ RenewalBuffer = 10 * time.Minute+ RenewalThreshold = 15 * time.Minute+)+var (hubAddr stringlistenAddrs []string@@ -202,91 +214,12 @@ func main() {}// Start renewal loop- go func() {- for {- var renewAfter = 50 * time.Minute // Default fallback-- exp, err := node.Store.LoadIdentityExpiration()- if err == nil && exp > 0 {- expTime := time.Unix(exp, 0)- duration := time.Until(expTime)- // Renew 10 minutes before expiration if duration permits- if duration > 15*time.Minute {- renewAfter = duration - 10*time.Minute- } else if duration > 0 {- renewAfter = duration / 2 // half of remaining time- } else {- renewAfter = 1 * time.Minute // already expired or immediate- }- }-- fmt.Printf("[Auth] Next renewal in %v\n", renewAfter)- timer := time.NewTimer(renewAfter)-- select {- case <-ctx.Done():- timer.Stop()- return- case <-timer.C:- fmt.Println("Renewing enrollment...")- var newJWT string- if tokenURLFlag != "" {- var err error- newJWT, err = node.FetchJWT(ctx, tokenURLFlag, clientIDFlag, clientSecretFlag)- if err != nil {- fmt.Printf("Failed to fetch JWT for renewal: %v\n", err)- continue- }- } else if jwtPathFlag != "" {- data, err := os.ReadFile(jwtPathFlag)- if err != nil {- fmt.Printf("Failed to read JWT file for renewal: %v\n", err)- continue- }- newJWT = strings.TrimSpace(string(data))- } else {- fmt.Println("No credentials available for renewal.")- continue- }-- if err := node.Enroll(ctx, newJWT); err != nil {- fmt.Printf("Renewal enrollment failed: %v\n", err)- } else {- fmt.Println("Enrollment renewed successfully.")- }- }- }- }()+ node.StartRenewalLoop(ctx, tokenURLFlag, clientIDFlag, clientSecretFlag, jwtPathFlag)node.Host.SetStreamHandler(AuthProtocolID, node.HandleAuthHandshake)// Start MCP Server- mcpHandler := NewMCPHandler(node)- go func() {- socketPath := mcpSocketFlag- if socketPath == "" {- socketPath = filepath.Join(dataDir, "mcp.sock")- }-- // Remove old socket file if it exists- _ = os.Remove(socketPath)-- listener, err := net.Listen("unix", socketPath)- if err != nil {- logger.Errorf("Failed to listen on Unix socket %s: %v", socketPath, err)- return- }- defer func() {- if err := listener.Close(); err != nil {- logger.Errorf("Failed to close listener: %v", err)- }- }()-- fmt.Printf("Starting MCP server on Unix socket %s\n", socketPath)- if err := http.Serve(listener, mcpHandler); err != nil {- logger.Errorf("MCP server error: %v", err)- }- }()+ startMCPServer(node, mcpSocketFlag, dataDir)fmt.Printf("SAM Node Online.\nPeerID: %s\nListening on: %v\n", node.Host.ID(), node.Host.Addrs())@@ -374,13 +307,13 @@ func main() {runCmd.Flags().StringVar(&clientSecretFlag, "client-secret", os.Getenv("SAM_OIDC_SECRET"), "OIDC Client Secret for M2M")runCmd.Flags().StringVar(&hubPublicKeyFlag, "hub-public-key", "", "Hub Public Key (32-byte Hex)")runCmd.Flags().StringVar(&mcpSocketFlag, "mcp-socket", "", "Path to Unix domain socket for local MCP server (default: <datadir>/mcp.sock)")- runCmd.Flags().StringVar(&meshFlag, "mesh", "public-mesh", "Mesh federation name")- runCmd.Flags().StringVar(&discoveryIntervalFlag, "discovery-interval", "2s", "Polling interval for DHT discovery")+ runCmd.Flags().StringVar(&meshFlag, "mesh", DefaultMeshName, "Mesh federation name")+ runCmd.Flags().StringVar(&discoveryIntervalFlag, "discovery-interval", DefaultDiscoveryInterval, "Polling interval for DHT discovery")runCmd.Flags().BoolVar(&enableRelayFlag, "enable-relay", false, "Allow this node to serve as a relay for others")runCmd.Flags().StringVar(&logLevelFlag, "log-level", "info", "Log level (debug, info, warn, error)")runCmd.Flags().DurationVar(&keyGracePeriodFlag, "key-grace-period", 24*time.Hour, "Key grace period for old keys (e.g. 24h)")- rootCmd.PersistentFlags().StringVar(&hubAddr, "hub", "http://localhost:8080", "Hub URL")- rootCmd.PersistentFlags().StringVar(&localPolicyFile, "local-policy", "local_policy.yaml", "Path to local_policy.yaml")+ rootCmd.PersistentFlags().StringVar(&hubAddr, "hub", DefaultHubURL, "Hub URL")+ rootCmd.PersistentFlags().StringVar(&localPolicyFile, "local-policy", DefaultLocalPolicyFile, "Path to local_policy.yaml")rootCmd.PersistentFlags().StringVar(&tokenURLFlag, "token-url", "", "OIDC Token URL")rootCmd.AddCommand(runCmd)@@ -424,6 +357,33 @@ func getOrGenerateKey(s *Store) crypto.PrivKey {return priv}+func startMCPServer(node *SamNode, socketPath string, dataDir string) {+ mcpHandler := NewMCPHandler(node)+ go func() {+ if socketPath == "" {+ socketPath = filepath.Join(dataDir, "mcp.sock")+ }++ _ = os.Remove(socketPath)++ listener, err := net.Listen("unix", socketPath)+ if err != nil {+ logger.Errorf("Failed to listen on Unix socket %s: %v", socketPath, err)+ return+ }+ defer func() {+ if err := listener.Close(); err != nil {+ logger.Errorf("Failed to close listener: %v", err)+ }+ }()++ fmt.Printf("Starting MCP server on Unix socket %s\n", socketPath)+ if err := http.Serve(listener, mcpHandler); err != nil {+ logger.Errorf("MCP server error: %v", err)+ }+ }()+}+func (n *SamNode) Enroll(ctx context.Context, jwt string) error {if n.HubPeerID == "" {return fmt.Errorf("not connected to any hub")diff --git a/cmd/sam-node/main_test.go b/cmd/sam-node/main_test.gonew file mode 100644index 00000000..ef4e9c2a--- /dev/null+++ b/cmd/sam-node/main_test.go@@ -0,0 +1,50 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package main++import (+ "bytes"+ "testing"++ "github.com/libp2p/go-libp2p/core/crypto"+)++func TestGetOrGenerateKey(t *testing.T) {+ dir := t.TempDir()+ store, err := NewStore(dir)+ if err != nil {+ t.Fatal(err)+ }+ defer func() { _ = store.Close() }()++ // First call should generate a key+ key1 := getOrGenerateKey(store)+ if key1 == nil {+ t.Fatal("Expected key to be generated")+ }++ // Second call should retrieve the same key+ key2 := getOrGenerateKey(store)+ if key2 == nil {+ t.Fatal("Expected key to be retrieved")+ }++ // Verify they are the same key+ raw1, _ := crypto.MarshalPrivateKey(key1)+ raw2, _ := crypto.MarshalPrivateKey(key2)+ if !bytes.Equal(raw1, raw2) {+ t.Error("Expected retrieved key to match generated key")+ }+}diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.goindex 9382b0ed..4cdf77e8 100644--- a/cmd/sam-node/node.go+++ b/cmd/sam-node/node.go@@ -16,6 +16,8 @@ package mainimport ("context"+ "os"+ "strings""crypto/ed25519""crypto/sha256""encoding/hex"@@ -47,7 +49,20 @@ import ("google.golang.org/protobuf/proto")-const AuthProtocolID = protocol.ID("/sam/auth/1.0.0")+const (+ AuthProtocolID = protocol.ID("/sam/auth/1.0.0")++ // Cache sizes+ RateLimiterSize = 1000+ RevocationCacheSize = 10000+ VerificationCacheSize = 1000++ // Freshness checks+ FreshnessThreshold = 5 * time.Minute++ // Key pruning+ KeyPruningInterval = 1 * time.Hour+)type TrustedKey struct {Key ed25519.PublicKey@@ -89,16 +104,16 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.P}var err error- node.rateLimiter, err = NewPeerRateLimiter(1000)+ node.rateLimiter, err = NewPeerRateLimiter(RateLimiterSize)if err != nil {return nil, fmt.Errorf("failed to create rate limiter: %w", err)}- node.revokedPeers, err = lru.New[string, int64](10000)+ node.revokedPeers, err = lru.New[string, int64](RevocationCacheSize)if err != nil {return nil, fmt.Errorf("failed to create revocation cache: %w", err)}- node.verificationCache, err = lru.New[string, string](1000)+ node.verificationCache, err = lru.New[string, string](VerificationCacheSize)if err != nil {return nil, fmt.Errorf("failed to create verification cache: %w", err)}@@ -201,8 +216,8 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.Pinterval, err := time.ParseDuration(discoveryInterval)if err != nil {- logger.Warnf("[Discovery] Invalid discovery interval '%s', using default 2s: %v", discoveryInterval, err)- interval = 2 * time.Second+ logger.Warnf("[Discovery] Invalid discovery interval '%s', using default %s: %v", discoveryInterval, DefaultDiscoveryInterval, err)+ interval, _ = time.ParseDuration(DefaultDiscoveryInterval)}// Start DHT Discovery@@ -220,6 +235,63 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.Preturn node, nil}+func (n *SamNode) StartRenewalLoop(ctx context.Context, tokenURL, clientID, clientSecret, jwtPath string) {+ go func() {+ for {+ var renewAfter = DefaultRenewalFallback // Default fallback++ exp, err := n.Store.LoadIdentityExpiration()+ if err == nil && exp > 0 {+ expTime := time.Unix(exp, 0)+ duration := time.Until(expTime)+ if duration > RenewalThreshold {+ renewAfter = duration - RenewalBuffer+ } else if duration > 0 {+ renewAfter = duration / 2+ } else {+ renewAfter = 1 * time.Minute+ }+ }++ fmt.Printf("[Auth] Next renewal in %v\n", renewAfter)+ timer := time.NewTimer(renewAfter)++ select {+ case <-ctx.Done():+ timer.Stop()+ return+ case <-timer.C:+ fmt.Println("Renewing enrollment...")+ var newJWT string+ if tokenURL != "" {+ var err error+ newJWT, err = n.FetchJWT(ctx, tokenURL, clientID, clientSecret)+ if err != nil {+ fmt.Printf("Failed to fetch JWT for renewal: %v\n", err)+ continue+ }+ } else if jwtPath != "" {+ data, err := os.ReadFile(jwtPath)+ if err != nil {+ fmt.Printf("Failed to read JWT file for renewal: %v\n", err)+ continue+ }+ newJWT = strings.TrimSpace(string(data))+ } else {+ fmt.Println("No credentials available for renewal.")+ continue+ }++ if err := n.Enroll(ctx, newJWT); err != nil {+ fmt.Printf("Renewal enrollment failed: %v\n", err)+ } else {+ fmt.Println("Enrollment renewed successfully.")+ }+ }+ }+ }()+}+// listenForHubEvents listens to the topic established by the Hubfunc (n *SamNode) listenForHubEvents(ctx context.Context) {topic, err := n.PubSub.Join(api.GossipEvents)@@ -259,47 +331,69 @@ func (n *SamNode) listenForHubEvents(ctx context.Context) {continue}- // Freshness check: reject events older than 5 minutes to prevent replay attacks- if time.Since(time.Unix(event.Timestamp, 0)) > 5*time.Minute {+ // Freshness check: reject events older than the threshold to prevent replay attacks+ if time.Since(time.Unix(event.Timestamp, 0)) > FreshnessThreshold {logger.Warnf("[Mesh Event] Dropping stale event from %s (timestamp: %d)", msg.ReceivedFrom, event.Timestamp)continue}- n.mu.Lock()switch event.Type {case api.MeshEvent_JOIN:- if event.PeerId != n.Host.ID().String() {- n.knownPeers[event.PeerId] = true- }- logger.Infof("[Mesh Event] Peer joined: %s", event.PeerId)+ n.handleJoinEvent(&event)case api.MeshEvent_EXIT:- delete(n.knownPeers, event.PeerId)- logger.Infof("[Mesh Event] Peer left: %s", event.PeerId)+ n.handleExitEvent(&event)case api.MeshEvent_BANNED:- delete(n.knownPeers, event.PeerId)- logger.Infof("[Mesh Event] Peer banned: %s", event.PeerId)-- n.revokedPeers.Add(event.PeerId, event.Timestamp)- // close all streams from this peer- if p, err := peer.Decode(event.PeerId); err == nil {- _ = n.Host.Network().ClosePeer(p)- }+ n.handleBannedEvent(&event)case api.MeshEvent_KEY_ROTATION:- logger.Infof("[Mesh Event] Key rotation received")- n.keysMu.Lock()- n.trustedKeys = append(n.trustedKeys, TrustedKey{Key: ed25519.PublicKey(event.NewPublicKey), ReceivedAt: time.Now()})- n.keysMu.Unlock()+ n.handleKeyRotationEvent(&event)}- n.mu.Unlock()}}+func (n *SamNode) handleJoinEvent(event *api.MeshEvent) {+ n.mu.Lock()+ defer n.mu.Unlock()+ if n.Host == nil || event.PeerId != n.Host.ID().String() {+ n.knownPeers[event.PeerId] = true+ }+ logger.Infof("[Mesh Event] Peer joined: %s", event.PeerId)+}++func (n *SamNode) handleExitEvent(event *api.MeshEvent) {+ n.mu.Lock()+ defer n.mu.Unlock()+ delete(n.knownPeers, event.PeerId)+ logger.Infof("[Mesh Event] Peer left: %s", event.PeerId)+}++func (n *SamNode) handleBannedEvent(event *api.MeshEvent) {+ n.mu.Lock()+ delete(n.knownPeers, event.PeerId)+ n.mu.Unlock()++ logger.Infof("[Mesh Event] Peer banned: %s", event.PeerId)++ n.revokedPeers.Add(event.PeerId, event.Timestamp)+ if p, err := peer.Decode(event.PeerId); err == nil {+ if n.Host != nil {+ _ = n.Host.Network().ClosePeer(p)+ }+ }+}++func (n *SamNode) handleKeyRotationEvent(event *api.MeshEvent) {+ logger.Infof("[Mesh Event] Key rotation received")+ n.keysMu.Lock()+ n.trustedKeys = append(n.trustedKeys, TrustedKey{Key: ed25519.PublicKey(event.NewPublicKey), ReceivedAt: time.Now()})+ n.keysMu.Unlock()+}+func (n *SamNode) startKeyPruning(ctx context.Context, gracePeriod time.Duration) {if gracePeriod <= 0 {return}go func() {- ticker := time.NewTicker(1 * time.Hour)+ ticker := time.NewTicker(KeyPruningInterval)defer ticker.Stop()for {select {@@ -444,8 +538,47 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {return}- // Check verification cache- tokenHash := sha256.Sum256(exchange.Biscuit)+ b, err := n.verifyBiscuit(exchange.Biscuit, remotePeer)+ if err != nil {+ logger.Warnf("[AuthN] Authorization failed for %s: %v", remotePeer, err)+ return+ }++ // 4. Enforce hardware binding: token must include node(<remotePeerID>)+ boundFact := biscuit.Fact{Predicate: biscuit.Predicate{+ Name: "node",+ IDs: []biscuit.Term{biscuit.String(remotePeer.String())},+ }}+ if _, err := b.GetBlockID(boundFact); err != nil {+ logger.Warnf("[AuthN] Token is not bound to peer %s", remotePeer)+ return+ }++ // Query for the standard facts we mapped in the Hub+ // user_id, user_email, group, mesh_id+ // Note: We use the authorizer to extract these values from the Datalog state+ identity := VerifiedIdentity{+ RawBiscuit: exchange.Biscuit,+ // In a full implementation, you would use authorizer.Query()+ // to extract specific strings like user_id and group.+ NodeID: remotePeer.String(), // Placeholder for Datalog query result+ UserID: "extracted_id", // Placeholder for Datalog query result+ UserEmail: "extracted_email", // Placeholder for Datalog query result+ MeshID: "extracted_mesh", // Placeholder for Datalog query result+ }++ // 5. Save to the persistent session cache (BoltDB)+ // Once saved here, the ConnectionGater and Middleware will "recognize" this peer.+ if err := n.Store.SaveVerifiedIdentity(remotePeer, identity); err != nil {+ logger.Errorf("[AuthN] Store error for %s: %v", remotePeer, err)+ return+ }++ logger.Infof("[AuthN] Successfully authenticated peer %s (%s)", remotePeer, identity.UserEmail)+}++func (n *SamNode) verifyBiscuit(biscuitData []byte, remotePeer peer.ID) (*biscuit.Biscuit, error) {+ tokenHash := sha256.Sum256(biscuitData)hashStr := hex.EncodeToString(tokenHash[:]) + ":" + remotePeer.String()if pubKeyStr, ok := n.verificationCache.Get(hashStr); ok {@@ -453,29 +586,22 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {keys := n.trustedKeysn.keysMu.RUnlock()- trusted := falsefor _, tk := range keys {if hex.EncodeToString(tk.Key) == pubKeyStr {- trusted = true- break+ b, err := biscuit.Unmarshal(biscuitData)+ if err != nil {+ return nil, fmt.Errorf("malformed biscuit on cache hit: %w", err)+ }+ return b, nil}}- if trusted {- logger.Infof("[AuthN] Token cache hit for %s", remotePeer)- return- }}- // 2. Unmarshal and verify token format- b, err := biscuit.Unmarshal(exchange.Biscuit)+ b, err := biscuit.Unmarshal(biscuitData)if err != nil {- logger.Warnf("[AuthN] Malformed biscuit from %s", remotePeer)- return+ return nil, fmt.Errorf("malformed biscuit: %w", err)}- authorized := false- var successfulKey ed25519.PublicKey- // 3. Verify signature chain against the trusted Hub keys.n.keysMu.RLock()keys := n.trustedKeysn.keysMu.RUnlock()@@ -489,60 +615,17 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {continue}- // Admission only requires a valid signature, so allow if truerule, err := parser.FromStringPolicy("allow if true")if err != nil {- logger.Errorf("[AuthN] Failed to parse rule: %v", err)continue}authorizer.AddPolicy(rule)if err := authorizer.Authorize(); err == nil {- authorized = true- successfulKey = tk.Key- break+ n.verificationCache.Add(hashStr, hex.EncodeToString(tk.Key))+ return b, nil}}- if authorized {- // Cache successful verification- n.verificationCache.Add(hashStr, hex.EncodeToString(successfulKey))- }-- if !authorized {- logger.Warnf("[AuthN] Authorization failed for %s: no valid key found", remotePeer)- return- }-- // 4. Enforce hardware binding: token must include node(<remotePeerID>)- boundFact := biscuit.Fact{Predicate: biscuit.Predicate{- Name: "node",- IDs: []biscuit.Term{biscuit.String(remotePeer.String())},- }}- if _, err := b.GetBlockID(boundFact); err != nil {- logger.Warnf("[AuthN] Token is not bound to peer %s", remotePeer)- return- }-- // Query for the standard facts we mapped in the Hub- // user_id, user_email, group, mesh_id- // Note: We use the authorizer to extract these values from the Datalog state- identity := VerifiedIdentity{- RawBiscuit: exchange.Biscuit,- // In a full implementation, you would use authorizer.Query()- // to extract specific strings like user_id and group.- NodeID: remotePeer.String(), // Placeholder for Datalog query result- UserID: "extracted_id", // Placeholder for Datalog query result- UserEmail: "extracted_email", // Placeholder for Datalog query result- MeshID: "extracted_mesh", // Placeholder for Datalog query result- }-- // 5. Save to the persistent session cache (BoltDB)- // Once saved here, the ConnectionGater and Middleware will "recognize" this peer.- if err := n.Store.SaveVerifiedIdentity(remotePeer, identity); err != nil {- logger.Errorf("[AuthN] Store error for %s: %v", remotePeer, err)- return- }-- logger.Infof("[AuthN] Successfully authenticated peer %s (%s)", remotePeer, identity.UserEmail)+ return nil, fmt.Errorf("no valid key found")}diff --git a/cmd/sam-node/node_test.go b/cmd/sam-node/node_test.gonew file mode 100644index 00000000..0d451ce2--- /dev/null+++ b/cmd/sam-node/node_test.go@@ -0,0 +1,103 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package main++import (+ "crypto/ed25519"+ "testing"+ "time"++ "github.com/google/sam/api"+ lru "github.com/hashicorp/golang-lru/v2"+)++func TestHandleJoinEvent(t *testing.T) {+ node := &SamNode{+ knownPeers: make(map[string]bool),+ }++ event := &api.MeshEvent{+ Type: api.MeshEvent_JOIN,+ PeerId: "12D3KooWAFv4iJst5G6MjwXhZ66K5zS1tP7A9vSg4vK8f1T7X8t9",+ }++ node.handleJoinEvent(event)++ if !node.knownPeers[event.PeerId] {+ t.Error("Expected peer to be added to knownPeers")+ }+}++func TestHandleExitEvent(t *testing.T) {+ node := &SamNode{+ knownPeers: map[string]bool{+ "12D3KooWAFv4iJst5G6MjwXhZ66K5zS1tP7A9vSg4vK8f1T7X8t9": true,+ },+ }++ event := &api.MeshEvent{+ Type: api.MeshEvent_EXIT,+ PeerId: "12D3KooWAFv4iJst5G6MjwXhZ66K5zS1tP7A9vSg4vK8f1T7X8t9",+ }++ node.handleExitEvent(event)++ if node.knownPeers[event.PeerId] {+ t.Error("Expected peer to be removed from knownPeers")+ }+}++func TestHandleBannedEvent(t *testing.T) {+ revokedCache, _ := lru.New[string, int64](10)+ node := &SamNode{+ knownPeers: map[string]bool{+ "12D3KooWAFv4iJst5G6MjwXhZ66K5zS1tP7A9vSg4vK8f1T7X8t9": true,+ },+ revokedPeers: revokedCache,+ }++ event := &api.MeshEvent{+ Type: api.MeshEvent_BANNED,+ PeerId: "12D3KooWAFv4iJst5G6MjwXhZ66K5zS1tP7A9vSg4vK8f1T7X8t9",+ Timestamp: time.Now().Unix(),+ }++ node.handleBannedEvent(event)++ if node.knownPeers[event.PeerId] {+ t.Error("Expected peer to be removed from knownPeers")+ }++ if !node.revokedPeers.Contains(event.PeerId) {+ t.Error("Expected peer to be added to revokedPeers")+ }+}++func TestHandleKeyRotationEvent(t *testing.T) {+ node := &SamNode{}++ _, pub, _ := ed25519.GenerateKey(nil)++ event := &api.MeshEvent{+ Type: api.MeshEvent_KEY_ROTATION,+ NewPublicKey: pub,+ }++ node.handleKeyRotationEvent(event)++ if len(node.trustedKeys) != 1 {+ t.Errorf("Expected 1 trusted key, got %d", len(node.trustedKeys))+ }+}