Skip to content

Agent Mesh

refactor and add test coverage

Antonio Ojea3c9bbdb86259
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.go
index 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 = 100
HighWaterMark = 400
ConnGracePeriod = 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 verification
if 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 []string
if 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.go
new file mode 100644
index 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.go
index 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 string
listenAddrs []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.go
new file mode 100644
index 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.go
index 9382b0ed..4cdf77e8 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -16,6 +16,8 @@ package main
import (
"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.P
interval, 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.P
return 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 Hub
func (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.trustedKeys
n.keysMu.RUnlock()
- trusted := false
for _, 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.trustedKeys
n.keysMu.RUnlock()
@@ -489,60 +615,17 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {
continue
}
- // Admission only requires a valid signature, so allow if true
rule, 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.go
new file mode 100644
index 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))
+ }
+}