Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
rename and add logic for drop nodes
Antonio Ojea2ca784e5568f
diff --git a/cmd/sam-hub/conngater.go b/cmd/sam-hub/hooks.gosimilarity index 75%rename from cmd/sam-hub/conngater.gorename to cmd/sam-hub/hooks.goindex 7166c390..0ac494e2 100644--- a/cmd/sam-hub/conngater.go+++ b/cmd/sam-hub/hooks.go@@ -1,6 +1,7 @@package mainimport (+ "fmt""sync""time"@@ -56,3 +57,21 @@ func (g *hubConnGate) InterceptUpgraded(c network.Conn) (bool, control.Disconnec// REJECT BY DEFAULT: If not authenticated via OIDC, block any other protocolreturn g.authenticated[c.RemotePeer()], control.DisconnectReason(0)}++var _ network.Notifiee = (*notifier)(nil)++type notifier struct {+ hub *Hub+}++func (n *notifier) Listen(network.Network, multiaddr.Multiaddr) {}+func (n *notifier) ListenClose(network.Network, multiaddr.Multiaddr) {}+func (n *notifier) Connected(network.Network, network.Conn) {}+func (n *notifier) Disconnected(_ network.Network, c network.Conn) {+ p := c.RemotePeer()+ n.hub.gater.mu.Lock()+ delete(n.hub.gater.authenticated, p)+ delete(n.hub.gater.pending, p)+ n.hub.gater.mu.Unlock()+ fmt.Printf("[Mesh] Peer %s disconnected. Authorization cleared.\n", p)+}diff --git a/cmd/sam-hub/hub.go b/cmd/sam-hub/main.gosimilarity index 87%rename from cmd/sam-hub/hub.gorename to cmd/sam-hub/main.goindex 0e358437..936c5d28 100644--- a/cmd/sam-hub/hub.go+++ b/cmd/sam-hub/main.go@@ -27,16 +27,9 @@ import ("golang.org/x/oauth2")-// Hub handles identity bridging and network discovery-type Hub struct {- Host host.Host- DHT *dht.IpfsDHT- OIDCConfig *oauth2.Config- Verifier *oidc.IDTokenVerifier- BiscuitKey ed25519.PrivateKey- MeshID string- gater *hubConnGate-}+const (+ GracePeriod = 60 * time.Second+)var (oidcIssuer string@@ -48,6 +41,17 @@ var (publicAddr string)+// Hub handles identity bridging and network discovery+type Hub struct {+ Host host.Host+ DHT *dht.IpfsDHT+ OIDCConfig *oauth2.Config+ Verifier *oidc.IDTokenVerifier+ BiscuitKey ed25519.PrivateKey+ MeshID string+ gater *hubConnGate+}+// NewHub starts a host supporting both QUIC and TCP (with TLS 1.3)func NewHub(ctx context.Context) (*Hub, error) {gater := newHubConnGate()@@ -84,14 +88,6 @@ func NewHub(ctx context.Context) (*Hub, error) {return nil, err}- conf := &oauth2.Config{- ClientID: clientID,- ClientSecret: clientSecret,- Endpoint: provider.Endpoint(),- RedirectURL: fmt.Sprintf("%s/callback", publicAddr),- Scopes: []string{oidc.ScopeOpenID, "profile", "email"},- }-// SAM_HUB_KEY stores an ed25519 seed as a 32-byte hex value.keyBytes, err := hex.DecodeString(biscuitHex)if err != nil || len(keyBytes) != 32 {@@ -99,15 +95,24 @@ func NewHub(ctx context.Context) (*Hub, error) {}bKey := ed25519.NewKeyFromSeed(keyBytes)- return &Hub{- Host: h,- DHT: kadDHT,- OIDCConfig: conf,+ hub := &Hub{+ Host: h,+ DHT: kadDHT,+ gater: gater,+ OIDCConfig: &oauth2.Config{+ ClientID: clientID,+ ClientSecret: clientSecret,+ Endpoint: provider.Endpoint(),+ RedirectURL: fmt.Sprintf("%s/callback", publicAddr),+ Scopes: []string{oidc.ScopeOpenID, "profile", "email"},+ },Verifier: provider.Verifier(&oidc.Config{ClientID: clientID}),BiscuitKey: bKey,MeshID: meshName,- gater: gater,- }, nil+ }++ h.Network().Notify(¬ifier{hub: hub})+ return hub, nil}func (h *Hub) handleLogin(w http.ResponseWriter, r *http.Request) {@@ -218,9 +223,31 @@ func (h *Hub) issueStandardBiscuit(p peer.ID, sub string, email string, groups [if err != nil {return "", err}- data, _ := t.Serialize()+ data, err := t.Serialize()+ if err != nil {+ return "", err+ }return base64.StdEncoding.EncodeToString(data), nil}++func (h *Hub) startWatchdog() {+ go func() {+ ticker := time.NewTicker(10 * time.Second)+ for range ticker.C {+ h.gater.mu.Lock()+ now := time.Now()+ for pID, connectedAt := range h.gater.pending {+ if now.Sub(connectedAt) > GracePeriod {+ fmt.Printf("[Security] Evicting unauthenticated peer: %s\n", pID)+ h.Host.Network().ClosePeer(pID)+ delete(h.gater.pending, pID)+ }+ }+ h.gater.mu.Unlock()+ }+ }()+}+func main() {rootCmd := &cobra.Command{Use: "sam-hub",@@ -233,34 +260,7 @@ func main() {}// Watchdog: Expel peers that connect but never finish OIDC- go func() {- const timeout = 60 * time.Second- ticker := time.NewTicker(10 * time.Second)- defer ticker.Stop()-- for {- select {- case <-ctx.Done():- return- case <-ticker.C:- h.gater.mu.Lock()- now := time.Now()- for pID, startTime := range h.gater.pending {- if now.Sub(startTime) > timeout {- log.Printf("GATER: Evicting peer %s (OIDC timeout exceeded)", pID)-- // 1. Physically sever the swarm connection- h.Host.Network().ClosePeer(pID)-- // 2. Cleanup gater state- delete(h.gater.authenticated, pID)- delete(h.gater.pending, pID)- }- }- h.gater.mu.Unlock()- }- }- }()+ h.startWatchdog()mux := http.NewServeMux()mux.HandleFunc("/login", h.handleLogin)diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.gonew file mode 100644index 00000000..eacb3178--- /dev/null+++ b/cmd/sam-node/main.go@@ -0,0 +1,143 @@+package main++import (+ "bufio"+ "context"+ "fmt"+ "log"+ "os"+ "strings"++ "github.com/libp2p/go-libp2p/core/crypto"+ "github.com/spf13/cobra"+)++var (+ hubAddr string+ listenAddrs []string+ tokenFlag string+)++func main() {+ rootCmd := &cobra.Command{+ Use: "sam-node",+ Short: "Sovereign Agent Mesh Node",+ }++ // LOGIN COMMAND: For Headless Environments+ loginCmd := &cobra.Command{+ Use: "login",+ Short: "Establish sovereign identity with the Hub",+ Run: func(cmd *cobra.Command, args []string) {+ dataDir, err := GetDataDir()+ if err != nil {+ log.Fatalf("Critical: %v", err)+ }++ store, err := NewStore(dataDir)+ if err != nil {+ log.Fatalf("Critical: %v", err)+ }+ defer store.Close()++ priv := getOrGenerateKey(store)+ // Temporary host to determine PeerID+ tempNode, err := NewSamNode(context.Background(), priv, []string{})+ if err != nil {+ log.Fatalf("Failed to initialize identity: %v", err)+ }++ loginURL := fmt.Sprintf("%s/login?peer_id=%s", hubAddr, tempNode.Host.ID())++ fmt.Println("--- Sovereign Identity Login ---")+ fmt.Printf("1. Please open the following URL in your browser:\n\n %s\n\n", loginURL)+ fmt.Println("2. Authenticate via your OIDC provider.")+ fmt.Println("3. Copy the 'Identity Biscuit' provided at the end of the flow.")+ fmt.Print("\nPaste your Identity Biscuit here: ")++ reader := bufio.NewReader(os.Stdin)+ token, err := reader.ReadString('\n')+ if err != nil {+ log.Fatalf("Failed to read input: %v", err)+ }+ token = strings.TrimSpace(token)++ if token == "" {+ log.Fatal("Error: No token provided.")+ }++ if err := store.SaveIdentity(token); err != nil {+ log.Fatalf("Failed to save identity: %v", err)+ }++ fmt.Printf("\nSuccess! Identity stored for PeerID: %s\n", tempNode.Host.ID())+ },+ }++ // RUN COMMAND: Start the Mesh+ runCmd := &cobra.Command{+ Use: "run",+ Short: "Start the sovereign mesh node",+ Run: func(cmd *cobra.Command, args []string) {+ dataDir, _ := GetDataDir()+ store, err := NewStore(dataDir)+ if err != nil {+ log.Fatalf("Failed to open store: %v", err)+ }+ defer store.Close()++ token := tokenFlag+ if token == "" {+ token, _ = store.LoadIdentity()+ }+ if token == "" {+ fmt.Println("No identity found. Please run 'sam-node login' or provide --token")+ return+ }++ priv := getOrGenerateKey(store)+ node, err := NewSamNode(context.Background(), priv, listenAddrs)+ if err != nil {+ log.Fatalf("Failed to start mesh node: %v", err)+ }++ // Register the mandatory sovereign auth hook+ node.Host.SetStreamHandler(AuthProtocol, node.HandleAuthHandshake)++ fmt.Printf("SAM Node Online.\nPeerID: %s\nListening on: %v\n", node.Host.ID(), listenAddrs)++ // Block forever+ select {}+ },+ }++ // Configure Flags+ runCmd.Flags().StringVar(&tokenFlag, "token", os.Getenv("SAM_NODE_TOKEN"), "Manual Identity Biscuit (overrides store)")+ runCmd.Flags().StringSliceVar(&listenAddrs, "listen", []string{"/ip4/0.0.0.0/udp/5001/quic-v1", "/ip4/0.0.0.0/tcp/5002"}, "libp2p Listen Addrs")+ rootCmd.PersistentFlags().StringVar(&hubAddr, "hub", "http://localhost:8080", "Hub URL (Default: app.sam-dev)")++ rootCmd.AddCommand(loginCmd, runCmd)+ if err := rootCmd.Execute(); err != nil {+ os.Exit(1)+ }+}++// getOrGenerateKey retrieves a persistent private key or creates one if it's the first run+func getOrGenerateKey(s *Store) crypto.PrivKey {+ kb, _ := s.LoadKey()+ if len(kb) == 0 {+ fmt.Println("[Store] Generating new Peer Identity...")+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)+ if err != nil {+ log.Fatalf("Failed to generate key: %v", err)+ }+ raw, _ := crypto.MarshalPrivateKey(priv)+ s.SaveKey(raw)+ return priv+ }+ priv, err := crypto.UnmarshalPrivateKey(kb)+ if err != nil {+ log.Fatalf("Corrupt key in store: %v", err)+ }+ return priv+}diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.gonew file mode 100644index 00000000..efd50c10--- /dev/null+++ b/cmd/sam-node/node.go@@ -0,0 +1,79 @@+package main++import (+ "context"+ "fmt"+ "sync"++ "github.com/libp2p/go-libp2p"+ dht "github.com/libp2p/go-libp2p-kad-dht"+ "github.com/libp2p/go-libp2p/core/crypto"+ "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/core/protocol"+ libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls"+ libp2pquic "github.com/libp2p/go-libp2p/p2p/transport/quic"+ "github.com/libp2p/go-libp2p/p2p/transport/tcp"+)++const AuthProtocol = protocol.ID("/sam/auth/1.0.0")++type SamNode struct {+ Host host.Host+ DHT *dht.IpfsDHT+ Store *Store+ TrustedPeers map[peer.ID]bool+ mu sync.RWMutex+}++// NewSamNode initializes a FIPS-compliant libp2p host+func NewSamNode(ctx context.Context, priv crypto.PrivKey, listenAddrs []string) (*SamNode, error) {+ h, err := libp2p.New(+ libp2p.Identity(priv),+ libp2p.ListenAddrStrings(listenAddrs...),+ libp2p.Transport(libp2pquic.NewTransport), // Preferred (UDP/QUIC)+ libp2p.Transport(tcp.NewTCPTransport), // Fallback (TCP)+ libp2p.Security(libp2ptls.ID, libp2ptls.New), // FIPS Compliant TLS 1.3+ )+ if err != nil {+ return nil, fmt.Errorf("failed to create libp2p host: %w", err)+ }++ return &SamNode{+ Host: h,+ TrustedPeers: make(map[peer.ID]bool),+ }, nil+}++// SecureStreamHandler implements the "Reject by Default" middleware+func (n *SamNode) SecureStreamHandler(pid protocol.ID, handler network.StreamHandler) {+ n.Host.SetStreamHandler(pid, func(s network.Stream) {+ n.mu.RLock()+ isTrusted := n.TrustedPeers[s.Conn().RemotePeer()]+ n.mu.RUnlock()++ if !isTrusted {+ // DROP: Peer has not completed the /sam/auth/1.0.0 handshake+ fmt.Printf("Blocked unauthorized stream request for %s from %s\n", pid, s.Conn().RemotePeer())+ s.Reset()+ return+ }++ handler(s)+ })+}++// HandleAuthHandshake handles incoming Identity Biscuits+func (n *SamNode) HandleAuthHandshake(s network.Stream) {+ defer s.Close()++ // MVP: Logic to read Biscuit from stream, verify against Hub Public Key,+ // and ensure it is bound to the connecting PeerID.++ n.mu.Lock()+ n.TrustedPeers[s.Conn().RemotePeer()] = true+ n.mu.Unlock()++ fmt.Printf("Peer %s authenticated successfully via Biscuit\n", s.Conn().RemotePeer())+}diff --git a/cmd/sam-node/store.go b/cmd/sam-node/store.gonew file mode 100644index 00000000..393b43e6--- /dev/null+++ b/cmd/sam-node/store.go@@ -0,0 +1,87 @@+package main++import (+ "fmt"+ "os"+ "path/filepath"++ "go.etcd.io/bbolt"+)++const (+ bucketIdentity = "identity"+ keyBiscuit = "identity_biscuit"+ keyPrivKey = "node_private_key"+)++type Store struct {+ db *bbolt.DB+}++func GetDataDir() (string, error) {+ base, err := os.UserConfigDir()+ if err != nil {+ return "", err+ }+ dir := filepath.Join(base, "sam-mesh")+ if err := os.MkdirAll(dir, 0700); err != nil {+ return "", err+ }+ return dir, nil+}++func NewStore(dir string) (*Store, error) {+ dbPath := filepath.Join(dir, "agent.db")+ db, err := bbolt.Open(dbPath, 0600, nil)+ if err != nil {+ return nil, err+ }++ err = db.Update(func(tx *bbolt.Tx) error {+ _, _ = tx.CreateBucketIfNotExists([]byte(bucketIdentity))+ return nil+ })++ return &Store{db: db}, err+}++func (s *Store) SaveIdentity(biscuit string) error {+ return s.db.Update(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ return b.Put([]byte(keyBiscuit), []byte(biscuit))+ })+}++func (s *Store) LoadIdentity() (string, error) {+ var val []byte+ _ = s.db.View(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ val = b.Get([]byte(keyBiscuit))+ return nil+ })+ if len(val) == 0 {+ return "", fmt.Errorf("no identity found")+ }+ return string(val), nil+}++func (s *Store) SaveKey(key []byte) error {+ return s.db.Update(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ return b.Put([]byte(keyPrivKey), key)+ })+}++func (s *Store) LoadKey() ([]byte, error) {+ var val []byte+ _ = s.db.View(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ val = b.Get([]byte(keyPrivKey))+ return nil+ })+ return val, nil+}++func (s *Store) Close() error {+ return s.db.Close()+}