Skip to content

Agent Mesh

use canonical peer ID string in revocation cache

Ibrahim1974442943d7
diff --git a/internal/node/node.go b/internal/node/node.go
index c67c296f..cf934824 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -303,11 +303,12 @@ func NewSamNode(cfg Options) (*SamNode, error) {
// bans from the first connection, instead of waiting for an event that
// was already published while this node was down.
for _, id := range cfg.BannedPeerIDs {
- if _, err := peer.Decode(id); err != nil {
+ p, err := peer.Decode(id)
+ if err != nil {
logger.Warnf("Ignoring undecodable banned peer ID %q from the control plane: %v", id, err)
continue
}
- node.revokedPeers.Add(id, time.Now().Unix())
+ node.revokedPeers.Add(p.String(), time.Now().UnixMilli())
}
node.peerLabelGate, err = lru.New[string, time.Time](labelGateCacheSize)
if err != nil {
@@ -1277,33 +1278,37 @@ func (n *SamNode) listenForControlPlaneEvents(ctx context.Context) {
}
func (n *SamNode) handleBannedEvent(event *api.MeshEvent) {
+ p, err := peer.Decode(event.PeerId)
+ if err != nil {
+ logger.Warnf("[Mesh Event] Ignoring BANNED event with undecodable peer ID %q: %v", event.PeerId, err)
+ return
+ }
+ canonicalID := p.String()
+
n.mu.Lock()
if n.peerLastEventTime == nil {
n.peerLastEventTime = make(map[string]int64)
}
- if event.Timestamp < n.peerLastEventTime[event.PeerId] {
- logger.Warnf("[Mesh Event] Dropping out-of-order BANNED event for peer %s (event timestamp: %d, last processed: %d)", event.PeerId, event.Timestamp, n.peerLastEventTime[event.PeerId])
+ if event.Timestamp < n.peerLastEventTime[canonicalID] {
+ logger.Warnf("[Mesh Event] Dropping out-of-order BANNED event for peer %s (event timestamp: %d, last processed: %d)", canonicalID, event.Timestamp, n.peerLastEventTime[canonicalID])
n.mu.Unlock()
return
}
- n.peerLastEventTime[event.PeerId] = event.Timestamp
-
+ n.peerLastEventTime[canonicalID] = event.Timestamp
n.mu.Unlock()
- logger.Infow("[Mesh Event] peer banned", "event", meshEventBanned, "peer", event.PeerId)
+ logger.Infow("[Mesh Event] peer banned", "event", meshEventBanned, "peer", canonicalID)
if n.revokedPeers != nil {
- n.revokedPeers.Add(event.PeerId, event.Timestamp)
+ n.revokedPeers.Add(canonicalID, event.Timestamp)
}
// Drop any prior admission, otherwise the relay ACL keeps honouring it.
// The cache entry above is not written to disk: a restarted node picks the
// ban back up from the control plane's ban set in /info (see
// SyncMeshConfig), which is also how an unban reaches it.
- if p, err := peer.Decode(event.PeerId); err == nil {
- n.authPeers.Delete(p)
- if n.Host != nil {
- _ = n.Host.Network().ClosePeer(p)
- }
+ n.authPeers.Delete(p)
+ if n.Host != nil {
+ _ = n.Host.Network().ClosePeer(p)
}
}
diff --git a/internal/node/node_test.go b/internal/node/node_test.go
index 6f2ad09c..7f980b4a 100644
--- a/internal/node/node_test.go
+++ b/internal/node/node_test.go
@@ -124,6 +124,43 @@ func TestHandleBannedEvent(t *testing.T) {
}
}
+func TestBannedPeerCanonicalisation(t *testing.T) {
+ priv, _, err := crypto.GenerateEd25519Key(nil)
+ if err != nil {
+ t.Fatalf("failed to generate key: %v", err)
+ }
+ p, err := peer.IDFromPrivateKey(priv)
+ if err != nil {
+ t.Fatalf("failed to derive peer ID: %v", err)
+ }
+ canonicalID := p.String()
+ cidv1ID := peer.ToCid(p).String()
+
+ revokedCache, err := lru.New[string, int64](10)
+ if err != nil {
+ t.Fatalf("failed to create revocation cache: %v", err)
+ }
+ node := &SamNode{
+ revokedPeers: revokedCache,
+ peerLastEventTime: make(map[string]int64),
+ BiscuitTimeout: 500 * time.Millisecond,
+ }
+
+ ts := time.Now().UnixMilli()
+ node.handleBannedEvent(&api.MeshEvent{
+ Type: api.MeshEvent_BANNED,
+ PeerId: cidv1ID,
+ Timestamp: ts,
+ })
+
+ if !node.revokedPeers.Contains(canonicalID) {
+ t.Errorf("revokedPeers missing canonical ID %q (event used %q)", canonicalID, cidv1ID)
+ }
+ if got := node.peerLastEventTime[canonicalID]; got != ts {
+ t.Errorf("peerLastEventTime[%q] = %d, want %d", canonicalID, got, ts)
+ }
+}
+
func TestHandleKeyRotationEvent(t *testing.T) {
node := &SamNode{BiscuitTimeout: 500 * time.Millisecond}
@@ -448,6 +485,41 @@ func TestNewSamNode_BiscuitTimeout(t *testing.T) {
})
}
+func TestNewSamNode_BannedPeerCanonicalisation(t *testing.T) {
+ bannedPriv, _, err := crypto.GenerateEd25519Key(nil)
+ if err != nil {
+ t.Fatalf("failed to generate key: %v", err)
+ }
+ p, err := peer.IDFromPrivateKey(bannedPriv)
+ if err != nil {
+ t.Fatalf("failed to derive peer ID: %v", err)
+ }
+ canonicalID := p.String()
+ cidv1ID := peer.ToCid(p).String()
+
+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatalf("failed to generate node key: %v", err)
+ }
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = store.Close() }()
+
+ node, err := NewSamNode(Options{
+ PrivKey: priv,
+ Store: store,
+ BannedPeerIDs: []string{cidv1ID},
+ })
+ if err != nil {
+ t.Fatalf("NewSamNode: %v", err)
+ }
+ if !node.revokedPeers.Contains(canonicalID) {
+ t.Errorf("revokedPeers missing canonical ID %q (seeded with %q)", canonicalID, cidv1ID)
+ }
+}
+
func TestNewSamNode_DHTOptions(t *testing.T) {
priv, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
store, _ := NewStore(t.TempDir())