Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
fix address advertisement
Antonio Ojeaf3aa3d967ccd
diff --git a/cmd/sam-hub/main.go.orig b/cmd/sam-hub/main.go.orignew file mode 100644index 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.goindex 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 tiif 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