Skip to content

Agent Mesh

fix(controlplane,identity,router): fix multi-key extraction, user revocation event, and router gossip listener

Antonio Ojea088ade79b058
diff --git a/internal/controlplane/server.go b/internal/controlplane/server.go
index 16df2db5..02c3a2fc 100644
--- a/internal/controlplane/server.go
+++ b/internal/controlplane/server.go
@@ -1731,6 +1731,10 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {
return
}
+ if err := s.mesh.PublishEvent(ctx, api.MeshEvent_BANNED, peerID, nil); err != nil {
+ logger.Warnf("Failed to publish BANNED event for node %s to mesh: %v", peerID, err)
+ }
+
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte("Node revoked successfully"))
}
diff --git a/internal/identity/biscuit.go b/internal/identity/biscuit.go
index b0684f9b..11a66bd6 100644
--- a/internal/identity/biscuit.go
+++ b/internal/identity/biscuit.go
@@ -348,9 +348,13 @@ func VerifyAndExtractPeerID(trustedPublicKeys []ed25519.PublicKey, biscuitData [
lastErr = err
continue
}
- authorizer = auth
- verified = true
- break
+ if err := auth.Authorize(); err == nil || errors.Is(err, biscuit.ErrNoMatchingPolicy) {
+ authorizer = auth
+ verified = true
+ break
+ } else {
+ lastErr = err
+ }
}
if !verified {
@@ -363,11 +367,6 @@ func VerifyAndExtractPeerID(trustedPublicKeys []ed25519.PublicKey, biscuitData [
return "", fmt.Errorf("failed to parse query rule: %w", err)
}
- // Trigger datalog engine evaluation to copy token facts to authorizer world
- if err := authorizer.Authorize(); err != nil && !errors.Is(err, biscuit.ErrNoMatchingPolicy) {
- return "", fmt.Errorf("authorizer evaluation error during peer extraction: %w", err)
- }
-
facts, err := authorizer.Query(peerRule)
if err != nil {
return "", fmt.Errorf("query failed: %w", err)
diff --git a/internal/identity/biscuit_test.go b/internal/identity/biscuit_test.go
index fa895ec2..da31b9db 100644
--- a/internal/identity/biscuit_test.go
+++ b/internal/identity/biscuit_test.go
@@ -483,3 +483,40 @@ func TestMintBiscuitToken_WithPolicyRoles(t *testing.T) {
}
})
}
+
+func TestVerifyAndExtractPeerID_MultipleTrustedKeys(t *testing.T) {
+ pub1, _, err := ed25519.GenerateKey(rand.Reader)
+ if err != nil {
+ t.Fatal(err)
+ }
+ pub2, priv2, err := ed25519.GenerateKey(rand.Reader)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ privNode, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ dummyPeer, err := peer.IDFromPrivateKey(privNode)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ biscuitData, err := MintBootstrapBiscuitToken(priv2, dummyPeer, api.RoleNode, time.Now().Add(1*time.Hour), nil)
+ if err != nil {
+ t.Fatalf("MintBootstrapBiscuitToken failed: %v", err)
+ }
+
+ // trustedPublicKeys has pub1 first, pub2 second (pub2 is the signer)
+ trustedKeys := []ed25519.PublicKey{pub1, pub2}
+
+ extractedPeer, err := VerifyAndExtractPeerID(trustedKeys, biscuitData)
+ if err != nil {
+ t.Fatalf("VerifyAndExtractPeerID failed with multiple trusted keys: %v", err)
+ }
+
+ if extractedPeer != dummyPeer {
+ t.Errorf("expected peer ID %s, got %s", dummyPeer, extractedPeer)
+ }
+}
diff --git a/internal/router/router.go b/internal/router/router.go
index 42a2157a..a6696706 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -270,11 +270,12 @@ func (r *Router) Start() error {
})
// 5. Start background routines
- r.wg.Add(4)
+ r.wg.Add(5)
go r.runLeaseRenewalLoop()
go r.runKeysSyncLoop()
go r.runFederationLoop()
go r.runBiscuitRenewalLoop()
+ go r.listenForHubEvents(r.ctx)
r.isReady.Store(true)
logger.Infof("Router Online. PeerID: %s, ListenAddrs: %v", r.Host.ID(), r.Host.Addrs())
@@ -515,6 +516,80 @@ func (r *Router) getTrustedPublicKeys() []ed25519.PublicKey {
return append([]ed25519.PublicKey(nil), r.trustedPublicKeys...)
}
+func (r *Router) verifyEvent(event *api.MeshEvent) bool {
+ sig := event.Signature
+ event.Signature = nil
+ data, err := proto.Marshal(event)
+ event.Signature = sig
+ if err != nil {
+ logger.Errorf("[Router Event] Failed to marshal event for verification: %v", err)
+ return false
+ }
+
+ keys := r.getTrustedPublicKeys()
+ for _, pubKey := range keys {
+ if len(pubKey) == ed25519.PublicKeySize && ed25519.Verify(pubKey, data, sig) {
+ return true
+ }
+ }
+ return false
+}
+
+func (r *Router) listenForHubEvents(ctx context.Context) {
+ defer r.wg.Done()
+ if r.EventTopic == nil {
+ return
+ }
+ sub, err := r.EventTopic.Subscribe()
+ if err != nil {
+ logger.Errorf("[Router Event] Failed to subscribe to GossipEvents topic: %v", err)
+ return
+ }
+ defer sub.Cancel()
+
+ for {
+ msg, err := sub.Next(ctx)
+ if err != nil {
+ return
+ }
+
+ var event api.MeshEvent
+ if err := proto.Unmarshal(msg.Data, &event); err != nil {
+ logger.Errorf("[Router Event] Failed to unmarshal event from %s: %v", msg.ReceivedFrom, err)
+ continue
+ }
+
+ if !r.verifyEvent(&event) {
+ logger.Warnf("[Router Event] Potential spoofing attempt: invalid signature on event from %s", msg.ReceivedFrom)
+ continue
+ }
+
+ eventTime := time.UnixMilli(event.Timestamp)
+ if time.Since(eventTime) > 5*time.Minute || time.Until(eventTime) > 5*time.Minute {
+ logger.Warnf("[Router Event] Dropping stale or future event from %s", msg.ReceivedFrom)
+ continue
+ }
+
+ switch event.Type {
+ case api.MeshEvent_BANNED:
+ if event.PeerId != "" {
+ if bannedPeer, err := peer.Decode(event.PeerId); err == nil {
+ logger.Infof("[Router Event] Received BANNED event for peer %s, evicting from authenticated peers", bannedPeer)
+ r.authenticatedPeers.Delete(bannedPeer)
+ if r.Host != nil {
+ _ = r.Host.Network().ClosePeer(bannedPeer)
+ }
+ }
+ }
+ case api.MeshEvent_KEY_ROTATION:
+ logger.Infof("[Router Event] Received KEY_ROTATION event, triggering key sync")
+ if err := r.syncKeys(); err != nil {
+ logger.Warnf("[Router Event] Failed to sync keys after KEY_ROTATION event: %v", err)
+ }
+ }
+ }
+}
+
func (r *Router) runKeysSyncLoop() {
defer r.wg.Done()
ticker := time.NewTicker(r.config.KeysSyncInterval)
diff --git a/internal/router/router_test.go b/internal/router/router_test.go
index 00465e8a..2649e398 100644
--- a/internal/router/router_test.go
+++ b/internal/router/router_test.go
@@ -587,4 +587,97 @@ func TestRouterProactiveRefreshReEnrollOn401(t *testing.T) {
}
}
+func TestRouterGossipSubBannedEvent(t *testing.T) {
+ issuer, mintToken := startCustomMockOIDC(t)
+ cp, cpStore, cpURL := setupControlPlane(t, issuer)
+ defer func() {
+ _ = cp.Close()
+ _ = cpStore.Close()
+ }()
+ tempDir := t.TempDir()
+ routerKeyPath := filepath.Join(tempDir, "router.key")
+
+ routerJWT := mintToken(map[string]interface{}{
+ "sub": "router-banned-test",
+ "groups": []string{"routers"},
+ "roles": []string{api.RoleRouter},
+ })
+
+ rOpts := Options{
+ ControlPlaneURL: cpURL,
+ ListenAddrs: []string{"/ip4/127.0.0.1/tcp/0"},
+ KeysSyncInterval: 20 * time.Second,
+ LeaseRenewInterval: 20 * time.Second,
+ OIDCToken: routerJWT,
+ KeysDBPath: routerKeyPath,
+ AllowLoopback: true,
+ BiscuitTimeout: 1 * time.Second,
+ }
+
+ r, err := NewRouter(context.Background(), rOpts)
+ if err != nil {
+ t.Fatalf("failed to create router: %v", err)
+ }
+ if err := r.Start(); err != nil {
+ t.Fatalf("failed to start router: %v", err)
+ }
+ defer func() { _ = r.Close() }()
+
+ privNode, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatalf("failed to generate node keypair: %v", err)
+ }
+ bannedPeerID, err := peer.IDFromPrivateKey(privNode)
+ if err != nil {
+ t.Fatalf("failed to get peer ID from keypair: %v", err)
+ }
+ bannedPeerIDStr := bannedPeerID.String()
+
+ // Manually insert bannedPeer into router's authenticatedPeers
+ r.authenticatedPeers.Store(bannedPeerID, true)
+ if _, ok := r.authenticatedPeers.Load(bannedPeerID); !ok {
+ t.Fatalf("failed to seed authenticatedPeers map")
+ }
+
+ // Get CP's signing key from store to sign the MeshEvent
+ cpPrivKey, _, err := cpStore.GetCurrentKey(context.Background())
+ if err != nil {
+ t.Fatalf("failed to get CP key: %v", err)
+ }
+
+ event := &api.MeshEvent{
+ Type: api.MeshEvent_BANNED,
+ PeerId: bannedPeerIDStr,
+ Timestamp: time.Now().UnixMilli(),
+ }
+ eventData, err := proto.Marshal(event)
+ if err != nil {
+ t.Fatalf("failed to marshal event: %v", err)
+ }
+ event.Signature = ed25519.Sign(cpPrivKey, eventData)
+ signedData, err := proto.Marshal(event)
+ if err != nil {
+ t.Fatalf("failed to marshal signed event: %v", err)
+ }
+
+ // Publish MeshEvent_BANNED to GossipEvents topic
+ if err := r.EventTopic.Publish(context.Background(), signedData); err != nil {
+ t.Fatalf("failed to publish MeshEvent_BANNED: %v", err)
+ }
+
+ // Poll until authenticatedPeers no longer contains bannedPeerID
+ deadline := time.Now().Add(5 * time.Second)
+ evicted := false
+ for time.Now().Before(deadline) {
+ if _, ok := r.authenticatedPeers.Load(bannedPeerID); !ok {
+ evicted = true
+ break
+ }
+ time.Sleep(50 * time.Millisecond)
+ }
+
+ if !evicted {
+ t.Errorf("expected peer %s to be evicted from authenticatedPeers upon receiving MeshEvent_BANNED", bannedPeerIDStr)
+ }
+}