Skip to content

Agent Mesh

rename and add logic for drop nodes

Antonio Ojea2ca784e5568f
diff --git a/cmd/sam-hub/conngater.go b/cmd/sam-hub/hooks.go
similarity index 75%
rename from cmd/sam-hub/conngater.go
rename to cmd/sam-hub/hooks.go
index 7166c390..0ac494e2 100644
--- a/cmd/sam-hub/conngater.go
+++ b/cmd/sam-hub/hooks.go
@@ -1,6 +1,7 @@
package main
import (
+ "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 protocol
return 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.go
similarity index 87%
rename from cmd/sam-hub/hub.go
rename to cmd/sam-hub/main.go
index 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(&notifier{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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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()
+}