Skip to content

Agent Mesh

fix address advertisement

Antonio Ojeaf3aa3d967ccd
diff --git a/cmd/sam-hub/main.go.orig b/cmd/sam-hub/main.go.orig
new file mode 100644
index 00000000..c5ab671c
--- /dev/null
+++ b/cmd/sam-hub/main.go.orig
@@ -0,0 +1,916 @@
+// 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 (
+ "github.com/libp2p/go-libp2p/core/network"
+ "github.com/prometheus/client_golang/prometheus"
+ "github.com/prometheus/client_golang/prometheus/promhttp"
+
+ "sync"
+
+ "github.com/libp2p/go-msgio"
+
+ "context"
+ "crypto/ed25519"
+ "crypto/tls"
+ "crypto/x509"
+ "encoding/hex"
+ "fmt"
+ "net"
+ "net/http"
+ "os"
+ "strings"
+ "sync/atomic"
+ "time"
+
+ "github.com/biscuit-auth/biscuit-go/v2"
+ "github.com/biscuit-auth/biscuit-go/v2/parser"
+ "github.com/coreos/go-oidc/v3/oidc"
+ "github.com/golang-jwt/jwt/v5"
+ "github.com/google/sam/api"
+ golog "github.com/ipfs/go-log/v2"
+ "github.com/libp2p/go-libp2p"
+ dht "github.com/libp2p/go-libp2p-kad-dht"
+ pubsub "github.com/libp2p/go-libp2p-pubsub"
+ "github.com/libp2p/go-libp2p/core/host"
+ "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"
+ "github.com/libp2p/go-libp2p/p2p/transport/websocket"
+ "github.com/multiformats/go-multiaddr"
+
+ "golang.org/x/time/rate"
+
+ "github.com/spf13/cobra"
+ "google.golang.org/protobuf/proto"
+)
+
+const (
+ GracePeriod = 60 * time.Second
+
+ // Rate limiting defaults
+ EnrollRateLimit = 10
+ EnrollBurst = 20
+
+ // ConnManager limits
+ LowWaterMark = 100
+ HighWaterMark = 400
+ ConnGracePeriod = 1 * time.Minute
+
+ // Timeouts
+ JWTVerificationTimeout = 10 * time.Second
+
+ // Defaults
+ DefaultOIDCIssuer = "https://accounts.google.com"
+ DefaultMeshName = "public-mesh"
+ DefaultPolicyFile = "policies.yaml"
+ DefaultKeysDBPath = "keys.db"
+ DefaultBindAddress = ":9090"
+)
+
+var isHubReady atomic.Bool
+
+var (
+ oidcIssuer string
+ clientID string
+ biscuitHex string
+ listenAddrs []string
+ meshName string
+ insecureSkipTLSVerify bool
+ logLevel string
+ policyFile string
+ keyRotationInterval time.Duration
+ keyGracePeriod time.Duration
+ keysDBPath string
+ bindAddress string
+ adminToken string
+ tlsCertFile string
+ tlsKeyFile string
+ tlsCAFile string
+ externalMultiaddrs []string
+ allowedAudiencesFlag string
+ allowLoopbackFlag bool
+)
+
+var logger = golog.Logger("sam-hub")
+
+type relayACL struct {
+ hub *Hub
+}
+
+func (a *relayACL) AllowReserve(p peer.ID, addr multiaddr.Multiaddr) bool {
+ _, ok := a.hub.authenticatedPeers.Load(p)
+ return ok
+}
+
+func (a *relayACL) AllowConnect(src peer.ID, srcAddr multiaddr.Multiaddr, dest peer.ID) bool {
+ _, ok := a.hub.authenticatedPeers.Load(src)
+ return ok
+}
+
+// Hub handles identity bridging and network discovery
+type Hub struct {
+ Host host.Host
+ DHT *dht.IpfsDHT
+ Providers map[string]*oidc.Provider
+ KeyRing *KeyRing
+ MeshID string
+ PubSub *pubsub.PubSub
+ EventTopic *pubsub.Topic
+ Policy *api.PolicyConfig
+ limiter *rate.Limiter
+ ExternalAddrs []string
+ AllowedAudiences []string
+ AllowLoopback bool
+ authenticatedPeers sync.Map
+}
+
+// NewHub starts a host supporting both QUIC and TCP (with TLS 1.3)
+func NewHub(ctx context.Context, policy *api.PolicyConfig, allowLoopback bool, mux *http.ServeMux, serverTlsConfig *tls.Config) (*Hub, 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)
+ }
+
+ opts := []libp2p.Option{
+ libp2p.ListenAddrStrings(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 allowLoopback {
+ return addrs
+ }
+ var filtered []multiaddr.Multiaddr
+ for _, addr := range addrs {
+ if !isLoopbackOrLinkLocal(addr) {
+ filtered = append(filtered, addr)
+ }
+ }
+ return filtered
+ }),
+ }
+ if mux != nil {
+ if serverTlsConfig != nil {
+ opts = append(opts, libp2p.Transport(websocket.New, websocket.WithHTTPHandler(mux), websocket.WithTLSConfig(serverTlsConfig)))
+ } else {
+ opts = append(opts, libp2p.Transport(websocket.New, websocket.WithHTTPHandler(mux)))
+ }
+ }
+
+ h, err := libp2p.New(opts...)
+ if err != nil {
+ return nil, err
+ }
+
+ kadDHT, err := dht.New(ctx, h, dht.Mode(dht.ModeServer), dht.ProtocolPrefix("/sam"))
+ if err != nil {
+ return nil, err
+ }
+ if err = kadDHT.Bootstrap(ctx); err != nil {
+ return nil, err
+ }
+
+ issuers := strings.Split(oidcIssuer, ",")
+ providers := make(map[string]*oidc.Provider)
+ for _, iss := range issuers {
+ iss = strings.TrimSpace(iss)
+ if iss == "" {
+ continue
+ }
+ var providerCtx = ctx
+ if insecureSkipTLSVerify {
+ tr := &http.Transport{
+ TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+ }
+ client := &http.Client{
+ Timeout: 30 * time.Second,
+ Transport: tr,
+ }
+ providerCtx = oidc.ClientContext(ctx, client)
+ }
+ provider, err := oidc.NewProvider(providerCtx, iss)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create provider for %s: %w", iss, err)
+ }
+ providers[iss] = provider
+ logger.Infof("[OIDC] Trusted issuer: %s", iss)
+ }
+
+ var initialSeed []byte
+ if biscuitHex != "" {
+ var err error
+ initialSeed, err = hex.DecodeString(strings.TrimSpace(biscuitHex))
+ if err != nil {
+ return nil, fmt.Errorf("failed to decode key flag: %w", err)
+ }
+ }
+ kr, err := NewKeyRing(keysDBPath, keyGracePeriod, initialSeed)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create keyring: %w", err)
+ }
+
+ var auds []string
+ for _, aud := range strings.Split(allowedAudiencesFlag, ",") {
+ aud = strings.TrimSpace(aud)
+ if aud != "" {
+ auds = append(auds, aud)
+ }
+ }
+ if len(auds) == 0 {
+ auds = []string{api.DefaultAudience}
+ }
+
+ hub := &Hub{
+ Host: h,
+ DHT: kadDHT,
+ Providers: providers,
+ KeyRing: kr,
+ MeshID: meshName,
+ Policy: policy,
+ limiter: rate.NewLimiter(rate.Limit(EnrollRateLimit), EnrollBurst),
+ ExternalAddrs: externalMultiaddrs,
+ AllowedAudiences: auds,
+ AllowLoopback: allowLoopback,
+ }
+ ps, err := pubsub.NewGossipSub(ctx, h)
+ if err != nil {
+ return nil, err
+ }
+ topic, err := ps.Join(api.GossipEvents)
+ if err != nil {
+ return nil, err
+ }
+
+ hub.PubSub = ps
+ hub.EventTopic = topic
+
+ _, err = relay.New(h, relay.WithACL(&relayACL{hub: hub}))
+ if err != nil {
+ return nil, err
+ }
+
+ h.SetStreamHandler(api.AuthProtocolID, hub.HandleAuthHandshake)
+
+ h.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)
+ }
+ },
+ })
+
+ return hub, nil
+}
+
+func (h *Hub) parseAndVerifyJWT(ctx context.Context, jwtStr string, allowedAudiences []string) (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)
+ }
+
+ // 1. Defend against downgrade attacks immediately
+ alg, ok := jwtToken.Header["alg"].(string)
+ if !ok || alg == "" || strings.ToLower(alg) == "none" {
+ return nil, nil, fmt.Errorf("invalid or missing alg header")
+ }
+
+ claims, ok := jwtToken.Claims.(jwt.MapClaims)
+ if !ok {
+ return nil, nil, fmt.Errorf("invalid JWT claims")
+ }
+ iss, _ := claims["iss"].(string)
+
+ // 2. Extract the audience
+ var aud string
+ switch a := claims["aud"].(type) {
+ case string:
+ aud = a
+ case []any:
+ if len(a) > 0 {
+ aud, _ = a[0].(string)
+ }
+ }
+
+ if aud == "" {
+ return nil, nil, fmt.Errorf("missing aud claim")
+ }
+
+ // 3. Verify the audience matches one of your expected tenants/platforms
+ validAudience := false
+ for _, allowed := range allowedAudiences {
+ if aud == allowed {
+ validAudience = true
+ break
+ }
+ }
+ if !validAudience {
+ return nil, nil, fmt.Errorf("untrusted audience: %s", aud)
+ }
+
+ // 4. Route to the correct provider
+ provider, ok := h.Providers[iss]
+ if !ok {
+ return nil, nil, fmt.Errorf("unknown issuer: %s", iss)
+ }
+
+ // 5. Verify cryptographic signature, bypassing the strict single-clientID check
+ // because we already validated the audience against our allowed list above.
+ verifier := provider.Verifier(&oidc.Config{
+ SkipClientIDCheck: true,
+ })
+
+ token, err := verifier.Verify(ctx, jwtStr)
+ if err != nil {
+ return nil, nil, fmt.Errorf("JWT validation failed: %w", err)
+ }
+
+ return claims, token, nil
+}
+
+func (h *Hub) mintBiscuitToken(claims jwt.MapClaims, token *oidc.IDToken, remotePeer peer.ID) ([]byte, error) {
+ var oidcRoles []string
+ if rolesAny, ok := claims["roles"].([]any); ok {
+ for _, r := range rolesAny {
+ if str, ok := r.(string); ok && str != "" {
+ oidcRoles = append(oidcRoles, str)
+ }
+ }
+ }
+
+ var oidcGroups []string
+ if groupsAny, ok := claims["groups"].([]any); ok {
+ for _, g := range groupsAny {
+ if str, ok := g.(string); ok && str != "" {
+ oidcGroups = append(oidcGroups, str)
+ }
+ }
+ }
+
+ oidcSub, _ := claims["sub"].(string)
+
+ // Resolve roles based on configured bindings and explicit OIDC roles
+ resolvedRoles := make(map[string]bool)
+ if h.Policy != nil {
+ // 1. Map OIDC groups and users to roles via configured bindings (RBAC mapping)
+ for _, b := range h.Policy.Bindings {
+ if b.Group != "" {
+ for _, cg := range oidcGroups {
+ if b.Group == cg {
+ resolvedRoles[b.Role] = true
+ }
+ }
+ }
+ if b.User != "" && oidcSub != "" {
+ if b.User == oidcSub {
+ resolvedRoles[b.Role] = true
+ }
+ }
+ }
+
+ // 2. Validate and accept pre-resolved OIDC roles directly if defined in policy (Zero-Trust check)
+ for _, r := range oidcRoles {
+ if _, exists := h.Policy.Roles[r]; exists {
+ resolvedRoles[r] = true
+ }
+ }
+ }
+
+ builder := biscuit.NewBuilder(h.KeyRing.GetCurrentKey())
+
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactExpiration,
+ IDs: []biscuit.Term{biscuit.Date(token.Expiry)},
+ }}); err != nil {
+ return nil, fmt.Errorf("failed to add expiration fact: %w", err)
+ }
+
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactNode,
+ IDs: []biscuit.Term{biscuit.String(remotePeer.String())},
+ }}); err != nil {
+ return nil, fmt.Errorf("failed to add node fact: %w", err)
+ }
+
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactClientPeerID,
+ IDs: []biscuit.Term{biscuit.String(remotePeer.String())},
+ }}); err != nil {
+ return nil, fmt.Errorf("failed to add client_peer_id fact: %w", err)
+ }
+
+ if oidcSub != "" {
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactUser,
+ IDs: []biscuit.Term{biscuit.String(oidcSub)},
+ }}); err != nil {
+ return nil, fmt.Errorf("failed to add user fact: %w", err)
+ }
+ }
+
+ // Assert original OIDC groups in the token (semantic audit trail)
+ seenGroups := make(map[string]bool)
+ for _, cg := range oidcGroups {
+ if seenGroups[cg] {
+ continue
+ }
+ seenGroups[cg] = true
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactGroup,
+ IDs: []biscuit.Term{biscuit.String(cg)},
+ }}); err != nil {
+ return nil, fmt.Errorf("failed to add group fact: %w", err)
+ }
+ }
+
+ // Assert resolved authorized roles in the token
+ for role := range resolvedRoles {
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactRole,
+ IDs: []biscuit.Term{biscuit.String(role)},
+ }}); err != nil {
+ return nil, fmt.Errorf("failed to add role fact: %w", err)
+ }
+
+ if h.Policy != nil {
+ if rolePolicy, ok := h.Policy.Roles[role]; ok {
+ for _, tool := range rolePolicy.MCP.AllowedTools {
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactMCPTool,
+ IDs: []biscuit.Term{biscuit.String(tool)},
+ }}); err != nil {
+ logger.Errorw("Failed to add MCP tool fact to biscuit", "peer_id", remotePeer, "tool", tool, "error", err)
+ }
+ }
+ for _, target := range rolePolicy.Network.AllowedTargets {
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: api.FactNetworkTarget,
+ IDs: []biscuit.Term{biscuit.String(target)},
+ }}); err != nil {
+ logger.Errorw("Failed to add network target fact to biscuit", "peer_id", remotePeer, "target", target, "error", err)
+ }
+ }
+ for _, customFact := range rolePolicy.CustomDatalog {
+ trimmed := strings.TrimRight(strings.TrimSpace(customFact), ";")
+ if trimmed == "" {
+ continue
+ }
+ func() {
+ defer func() {
+ if r := recover(); r != nil {
+ logger.Errorw("Panic parsing custom fact", "peer_id", remotePeer, "fact", trimmed, "recover", r)
+ }
+ }()
+ fact, err := parser.FromStringFact(trimmed)
+ if err != nil {
+ logger.Errorw("Failed to parse custom fact", "peer_id", remotePeer, "fact", trimmed, "error", err)
+ return
+ }
+ if err := builder.AddAuthorityFact(fact); err != nil {
+ logger.Errorw("Failed to add custom fact to biscuit", "peer_id", remotePeer, "fact", trimmed, "error", err)
+ }
+ }()
+ }
+ }
+ }
+ }
+
+ t, err := builder.Build()
+ if err != nil {
+ return nil, fmt.Errorf("failed to build biscuit: %w", err)
+ }
+
+ biscuitData, err := t.Serialize()
+ if err != nil {
+ return nil, fmt.Errorf("failed to serialize biscuit: %w", err)
+ }
+
+ return biscuitData, nil
+}
+
+// startWatchdog periodically checks for peers that have connected but not completed OIDC
+// authentication within the grace period, and evicts them from the network.
+
+func (h *Hub) startRotation(ctx context.Context) {
+ if keyRotationInterval <= 0 {
+ return
+ }
+ go func() {
+ ticker := time.NewTicker(keyRotationInterval)
+ defer ticker.Stop()
+ for {
+ select {
+ case <-ticker.C:
+ logger.Infow("Rotating keys")
+ newPub, newPriv, oldPriv, err := h.KeyRing.PrepareRotation()
+ if err != nil {
+ logger.Errorw("Failed to prepare key rotation", "error", err)
+ continue
+ }
+ samHubKeyRotationsTotal.Inc()
+
+ // Broadcast event
+ event := &api.MeshEvent{
+ Type: api.MeshEvent_KEY_ROTATION,
+ Timestamp: time.Now().UnixMilli(),
+ NewPublicKey: newPub,
+ }
+
+ // Sign with the OLD key so nodes can verify it!
+ event.Signature = nil
+ data, err := proto.Marshal(event)
+ if err != nil {
+ logger.Errorw("Failed to marshal key rotation event", "error", err)
+ continue
+ }
+ event.Signature = ed25519.Sign(oldPriv, data)
+
+ eventData, err := proto.Marshal(event)
+ if err != nil {
+ logger.Errorw("Failed to marshal key rotation event", "error", err)
+ continue
+ }
+ if err := h.EventTopic.Publish(ctx, eventData); err != nil {
+ logger.Errorw("Failed to publish key rotation event", "error", err)
+ } else {
+ logger.Infow("Broadcasted new public key", "public_key", hex.EncodeToString(newPub))
+ samHubMeshEventsTotal.WithLabelValues("KEY_ROTATION").Inc()
+
+ // Promote the new key after successful broadcast
+ if err := h.KeyRing.CommitRotation(newPub, newPriv, keyGracePeriod); err != nil {
+ logger.Errorw("Failed to commit key rotation", "error", err)
+ } else {
+ logger.Infow("Committed new key to keyring")
+ }
+ }
+ case <-ctx.Done():
+ return
+ }
+ }
+ }()
+}
+
+func (h *Hub) signEvent(event *api.MeshEvent) error {
+ event.Signature = nil
+ data, err := proto.Marshal(event)
+ if err != nil {
+ return err
+ }
+ event.Signature = ed25519.Sign(h.KeyRing.GetCurrentKey(), data)
+ return nil
+}
+
+func (h *Hub) PublishEvent(ctx context.Context, event *api.MeshEvent) error {
+ if err := h.signEvent(event); err != nil {
+ return err
+ }
+ data, err := proto.Marshal(event)
+ if err != nil {
+ return err
+ }
+ return h.EventTopic.Publish(ctx, data)
+}
+
+func main() {
+ rootCmd := &cobra.Command{
+ Use: "sam-hub",
+ Short: "Sovereign Agent Mesh - Multi-Transport Hub",
+ Run: func(cmd *cobra.Command, args []string) {
+ ctx := cmd.Context()
+ // Initialize logging
+ if os.Getenv("LOG_FORMAT") == "json" {
+ _ = os.Setenv("GOLOG_LOG_FMT", "json")
+ }
+ golog.SetAllLoggers(golog.LevelInfo)
+ if logLevel != "" {
+ lvl, err := golog.LevelFromString(logLevel)
+ if err == nil {
+ golog.SetAllLoggers(lvl)
+ }
+ }
+
+ policyConfig, err := LoadPolicyConfig(policyFile)
+ if err != nil {
+ logger.Fatal(err)
+ }
+
+ // Add websocket listen address based on bindAddress
+ host, port, err := net.SplitHostPort(bindAddress)
+ if err != nil {
+ // if bindAddress is just ":9090"
+ if strings.HasPrefix(bindAddress, ":") {
+ host = "0.0.0.0"
+ port = strings.TrimPrefix(bindAddress, ":")
+ } else {
+ logger.Fatalf("Invalid bind address: %v", err)
+ }
+ }
+ if host == "" {
+ host = "0.0.0.0"
+ }
+ ipVersion := "ip4"
+ if strings.Contains(host, ":") {
+ ipVersion = "ip6"
+ }
+ var serverTlsConfig *tls.Config
+ wsScheme := "ws"
+ if tlsCertFile != "" && tlsKeyFile != "" {
+ cert, err := tls.LoadX509KeyPair(tlsCertFile, tlsKeyFile)
+ if err != nil {
+ logger.Fatalf("Failed to load TLS cert: %v", err)
+ }
+ serverTlsConfig = &tls.Config{
+ Certificates: []tls.Certificate{cert},
+ }
+ wsScheme = "wss"
+ }
+ wsAddr := fmt.Sprintf("/%s/%s/tcp/%s/%s", ipVersion, host, port, wsScheme)
+ listenAddrs = append(listenAddrs, wsAddr)
+
+ var hRef atomic.Pointer[Hub]
+
+ mux := http.NewServeMux()
+ mux.Handle("/metrics", promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{}))
+ mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
+ if isHubReady.Load() {
+ w.WriteHeader(http.StatusOK)
+ _, _ = w.Write([]byte("ok"))
+ } else {
+ w.WriteHeader(http.StatusServiceUnavailable)
+ _, _ = w.Write([]byte("not ready"))
+ }
+ })
+
+ // Register Hub-specific HTTP routes using an atomic pointer to avoid data races
+ mux.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
+ if h := hRef.Load(); h != nil {
+ handleRegisterHTTP(h)(w, r)
+ } else {
+ http.Error(w, "Hub not ready", http.StatusServiceUnavailable)
+ }
+ })
+ mux.HandleFunc("/info", func(w http.ResponseWriter, r *http.Request) {
+ if h := hRef.Load(); h != nil {
+ handleInfoHTTP(h)(w, r)
+ } else {
+ http.Error(w, "Hub not ready", http.StatusServiceUnavailable)
+ }
+ })
+ mux.HandleFunc("/admin/ban", func(w http.ResponseWriter, r *http.Request) {
+ if adminToken != "" {
+ authHeader := r.Header.Get("Authorization")
+ if authHeader != "Bearer "+adminToken {
+ http.Error(w, "Unauthorized", http.StatusUnauthorized)
+ return
+ }
+ }
+ if h := hRef.Load(); h != nil {
+ handleBan(h)(w, r)
+ } else {
+ http.Error(w, "Hub not ready", http.StatusServiceUnavailable)
+ }
+ })
+
+ h, err := NewHub(ctx, policyConfig, allowLoopbackFlag, mux, serverTlsConfig)
+ if err != nil {
+ logger.Fatal(err)
+ }
+ hRef.Store(h)
+
+ // Start key rotation if enabled
+ h.startRotation(ctx)
+
+ logger.Infof("SAM Hub Online (QUIC + TCP + WS on %s)", bindAddress)
+ isHubReady.Store(true)
+ logger.Infof("MeshID: %s", h.MeshID)
+ logger.Infof("PeerID: %s", h.Host.ID())
+
+ logger.Infof("Hub running on P2P transports only.")
+ <-ctx.Done()
+ },
+ }
+
+ defIssuer := os.Getenv("SAM_OIDC_ISSUER")
+ if defIssuer == "" {
+ 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(&externalMultiaddrs, "external-multiaddr", []string{}, "External multiaddrs to announce")
+ rootCmd.Flags().StringVar(&meshName, "mesh", DefaultMeshName, "Mesh federation name")
+ rootCmd.Flags().StringVar(&allowedAudiencesFlag, "allowed-audiences", api.DefaultAudience, "Comma-separated list of allowed OIDC audiences")
+ 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", 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", 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")
+ rootCmd.PersistentFlags().StringVar(&tlsCAFile, "tls-ca-file", "", "Path to CA certificate to verify client certificates (enables mTLS)")
+ rootCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")
+
+ var peerToBan string
+ var banReason string
+ var connectAddr string
+
+ adminCmd := &cobra.Command{
+ Use: "admin",
+ Short: "Administrative commands for SAM Hub",
+ }
+
+ banCmd := &cobra.Command{
+ Use: "ban",
+ Short: "Ban a peer from the mesh",
+ Run: func(cmd *cobra.Command, args []string) {
+ if peerToBan == "" {
+ logger.Fatal("Missing --peer flag")
+ }
+
+ targetAddr := bindAddress
+ if strings.HasPrefix(targetAddr, ":") {
+ targetAddr = "localhost" + targetAddr
+ }
+
+ scheme := "http"
+ var tlsConfig *tls.Config
+ if tlsCertFile != "" || tlsCAFile != "" {
+ scheme = "https"
+ tlsConfig = &tls.Config{
+ InsecureSkipVerify: true, // For tests, usually self-signed
+ }
+ if tlsCAFile != "" {
+ caCert, err := os.ReadFile(tlsCAFile)
+ if err != nil {
+ logger.Fatalf("Failed to read CA cert: %v", err)
+ }
+ caCertPool := x509.NewCertPool()
+ caCertPool.AppendCertsFromPEM(caCert)
+ tlsConfig.RootCAs = caCertPool
+ tlsConfig.InsecureSkipVerify = false // Verify if CA is provided!
+ }
+ }
+
+ client := &http.Client{
+ Timeout: 30 * time.Second,
+ Transport: &http.Transport{
+ TLSClientConfig: tlsConfig,
+ },
+ }
+
+ url := fmt.Sprintf("%s://%s/admin/ban?peer=%s", scheme, targetAddr, peerToBan)
+ req, err := http.NewRequest("POST", url, nil)
+ if err != nil {
+ logger.Fatalf("Failed to create request: %v", err)
+ }
+
+ if adminToken != "" {
+ req.Header.Set("Authorization", "Bearer "+adminToken)
+ }
+
+ resp, err := client.Do(req)
+ if err != nil {
+ logger.Fatalf("Failed to send ban request: %v", err)
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ if resp.StatusCode != http.StatusOK {
+ logger.Fatalf("Ban request failed: %s", resp.Status)
+ }
+
+ fmt.Printf("Published BANNED event for peer %s\n", peerToBan)
+ },
+ }
+
+ banCmd.Flags().StringVar(&peerToBan, "peer", "", "Peer ID to ban")
+ banCmd.Flags().StringVar(&banReason, "reason", "", "Reason for banning")
+ banCmd.Flags().StringVar(&connectAddr, "connect", "", "Address of a peer in the mesh to connect to")
+
+ adminCmd.AddCommand(banCmd)
+ rootCmd.AddCommand(adminCmd)
+
+ if err := rootCmd.Execute(); err != nil {
+ os.Exit(1)
+ }
+}
+
+func isLoopbackOrLinkLocal(addr multiaddr.Multiaddr) bool {
+ for _, proto := range addr.Protocols() {
+ if proto.Code == multiaddr.P_IP4 || proto.Code == multiaddr.P_IP6 {
+ value, err := addr.ValueForProtocol(proto.Code)
+ if err == nil {
+ ip := net.ParseIP(value)
+ if ip != nil {
+ if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
+ return true
+ }
+ }
+ }
+ }
+ }
+ return false
+}
+
+func (h *Hub) verifyBiscuit(biscuitData []byte, remotePeer peer.ID) (*biscuit.Biscuit, error) {
+ b, err := biscuit.Unmarshal(biscuitData)
+ if err != nil {
+ return nil, fmt.Errorf("malformed biscuit: %w", err)
+ }
+
+ keys := h.KeyRing.GetAllValidPublicKeys()
+ var lastErr error
+ for _, pubKey := range keys {
+ authorizer, err := b.Authorizer(pubKey)
+ if err != nil {
+ lastErr = err
+ continue
+ }
+
+ rule, err := parser.FromStringPolicy("allow if true")
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ authorizer.AddPolicy(rule)
+
+ if err := authorizer.Authorize(); err == nil {
+ return b, nil
+ } else {
+ lastErr = err
+ }
+ }
+
+ return nil, fmt.Errorf("no valid key found for verification: %v", lastErr)
+}
+
+func (h *Hub) HandleAuthHandshake(s network.Stream) {
+ defer func() {
+ if err := s.Close(); err != nil {
+ logger.Debugf("[AuthN] Failed to close auth stream: %v", err)
+ }
+ }()
+ remotePeer := s.Conn().RemotePeer()
+
+ reader := msgio.NewVarintReaderSize(s, 1024*64)
+ msg, err := reader.ReadMsg()
+ if err != nil {
+ logger.Errorf("[AuthN] Failed to read handshake from %s: %v", remotePeer, err)
+ return
+ }
+ defer reader.ReleaseMsg(msg)
+
+ var exchange api.AuthFrame
+ if err := proto.Unmarshal(msg, &exchange); err != nil {
+ logger.Warnf("[AuthN] Invalid protobuf from %s", remotePeer)
+ return
+ }
+
+ b, err := h.verifyBiscuit(exchange.Biscuit, remotePeer)
+ if err != nil {
+ logger.Warnf("[AuthN] Authorization failed for %s: %v", remotePeer, err)
+ return
+ }
+
+ // Enforce hardware binding
+ 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
+ }
+
+ h.authenticatedPeers.Store(remotePeer, true)
+ logger.Infof("[AuthN] Successfully authenticated peer %s", remotePeer)
+
+ writer := msgio.NewVarintWriter(s)
+ resp := &api.AuthResponse{Success: true}
+ respBytes, _ := proto.Marshal(resp)
+ if err := writer.WriteMsg(respBytes); err != nil {
+ logger.Errorf("[AuthN] Failed to write ACK to %s: %v", remotePeer, err)
+ }
+}
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index b3822f26..fa27561a 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -756,23 +756,9 @@ func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval ti
if n.Host.Network().Connectedness(p.ID) != network.Connected {
logger.Infof("[Discovery] Found peer not connected via DHT: %s", p.ID)
- // Add relay addresses to the peer if HubPeerID is known
- if n.HubPeerID != "" && p.ID != n.Host.ID() && p.ID != n.HubPeerID {
- baseAddrs := n.Host.Peerstore().Addrs(n.HubPeerID)
- if circuitMaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/p2p-circuit/p2p/%s", p.ID)); err == nil {
- for _, ba := range baseAddrs {
- p2pStr := fmt.Sprintf("/p2p/%s", n.HubPeerID)
- if !strings.Contains(ba.String(), p2pStr) {
- if p2pMaddr, err := multiaddr.NewMultiaddr(p2pStr); err == nil {
- ba = ba.Encapsulate(p2pMaddr)
- }
- }
- fullAddr := ba.Encapsulate(circuitMaddr)
- p.Addrs = append(p.Addrs, fullAddr)
- n.Host.Peerstore().AddAddr(p.ID, fullAddr, time.Minute*10)
- logger.Infof("[Discovery] Added relay address for DHT peer %s: %s", p.ID, fullAddr)
- }
- }
+ // Log the addresses returned by DHT to confirm they include p2p-circuit paths
+ for _, addr := range p.Addrs {
+ logger.Infof("[Discovery] Peer %s advertised address: %s", p.ID, addr)
}
go func(pi peer.AddrInfo) {
@@ -948,24 +934,14 @@ func (n *SamNode) findProvidersByCID(ctx context.Context, c cid.Cid) ([]peer.Add
}
logger.Infof("[Discovery] Evaluating relay for %s: HubPeerID=%s, HubAddrsCount=%d", p.ID, n.HubPeerID, hubAddrsCount)
- if n.HubPeerID != "" && p.ID != n.Host.ID() && p.ID != n.HubPeerID {
- baseAddrs := n.Host.Peerstore().Addrs(n.HubPeerID)
-
- if circuitMaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/p2p-circuit/p2p/%s", p.ID)); err == nil {
- for _, ba := range baseAddrs {
- p2pStr := fmt.Sprintf("/p2p/%s", n.HubPeerID)
- if !strings.Contains(ba.String(), p2pStr) {
- if p2pMaddr, err := multiaddr.NewMultiaddr(p2pStr); err == nil {
- ba = ba.Encapsulate(p2pMaddr)
- }
- }
- fullAddr := ba.Encapsulate(circuitMaddr)
- p.Addrs = append(p.Addrs, fullAddr)
- n.Host.Peerstore().AddAddr(p.ID, fullAddr, time.Minute*10)
- logger.Infof("[Discovery] Added relay address for %s: %s", p.ID, fullAddr)
- }
- }
+ for _, addr := range p.Addrs {
+ logger.Infof("[Discovery] Provider %s advertised address: %s", p.ID, addr)
+ }
+
+ if len(p.Addrs) > 0 {
+ n.Host.Peerstore().AddAddrs(p.ID, p.Addrs, peerstore.TempAddrTTL)
}
+
providers = append(providers, p)
}
return providers, nil