Skip to content

Agent Mesh

avoid replay attacks

Antonio Ojeaec674fc1116b
diff --git a/cmd/sam-hub/keyring_test.go b/cmd/sam-hub/keyring_test.go
index 0f459f73..26d398c8 100644
--- a/cmd/sam-hub/keyring_test.go
+++ b/cmd/sam-hub/keyring_test.go
@@ -29,7 +29,7 @@ func TestNewKeyRing(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- defer kr.Close()
+ defer func() { _ = kr.Close() }()
if len(kr.Current.Private) == 0 {
t.Error("Expected current private key to be initialized")
@@ -47,7 +47,7 @@ func TestKeyRingRotate(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- defer kr.Close()
+ defer func() { _ = kr.Close() }()
oldPub := kr.Current.Public
@@ -78,14 +78,14 @@ func TestKeyRingPersistence(t *testing.T) {
}
currentPub := kr.Current.Public
- kr.Close()
+ _ = kr.Close()
// Reopen
kr2, err := NewKeyRing(dbPath, 24*time.Hour)
if err != nil {
t.Fatal(err)
}
- defer kr2.Close()
+ defer func() { _ = kr2.Close() }()
if !bytes.Equal(kr2.Current.Public, currentPub) {
t.Error("Expected persisted public key to match original")
@@ -100,7 +100,7 @@ func TestKeyRingCleanup(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- defer kr.Close()
+ defer func() { _ = kr.Close() }()
oldPub := kr.Current.Public
diff --git a/cmd/sam-node/middleware_test.go b/cmd/sam-node/middleware_test.go
index 7233adb3..2bc0e5e9 100644
--- a/cmd/sam-node/middleware_test.go
+++ b/cmd/sam-node/middleware_test.go
@@ -16,6 +16,8 @@ package main
import (
"crypto/ed25519"
+ "crypto/sha256"
+ "encoding/hex"
"io"
"os"
"path/filepath"
@@ -395,3 +397,105 @@ func TestVerifyEvent(t *testing.T) {
t.Error("Expected event verification to fail for missing signature, got true")
}
}
+
+func TestHandleAuthHandshakeCache(t *testing.T) {
+ pub, priv, err := ed25519.GenerateKey(nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ dummyPeer := peer.ID("dummy-peer-id")
+
+ builder := biscuit.NewBuilder(priv)
+ err = builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: "node",
+ IDs: []biscuit.Term{biscuit.String(dummyPeer.String())},
+ }})
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b, err := builder.Build()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ tokenBytes, err := b.Serialize()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ cache, _ := lru.New[string, bool](10)
+
+ dir := t.TempDir()
+ store, err := NewStore(dir)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = store.Close() }()
+
+ node := &SamNode{
+ trustedKeys: []TrustedKey{{Key: pub, ReceivedAt: time.Now()}},
+ verificationCache: cache,
+ Store: store,
+ }
+
+ pr1, pw1 := io.Pipe()
+
+ serverStream := &mockStream{r: pr1, w: io.Discard, protocol: protocol.ID("/sam/auth/1.0.0")}
+
+ go func() {
+ node.HandleAuthHandshake(serverStream)
+ }()
+
+ writer := msgio.NewVarintWriter(pw1)
+ envelope := &api.AuthEnvelope{Biscuit: tokenBytes}
+ envelopeBytes, _ := proto.Marshal(envelope)
+ if err := writer.WriteMsg(envelopeBytes); err != nil {
+ t.Fatal(err)
+ }
+
+ time.Sleep(1 * time.Second)
+
+ _, err = store.GetVerifiedIdentity(dummyPeer)
+ if err != nil {
+ t.Fatalf("Expected identity to be saved, got err: %v", err)
+ }
+
+ tokenHash := sha256.Sum256(tokenBytes)
+ hashStr := hex.EncodeToString(tokenHash[:])
+
+ if valid, ok := cache.Get(hashStr); !ok || !valid {
+ t.Fatal("Expected token to be in verification cache")
+ }
+
+ // Now corrupt keys and try again.
+ node.keysMu.Lock()
+ node.trustedKeys = []TrustedKey{{Key: []byte("invalid-key"), ReceivedAt: time.Now()}}
+ node.keysMu.Unlock()
+
+ dir2 := t.TempDir()
+ store2, _ := NewStore(dir2)
+ defer func() { _ = store2.Close() }()
+
+ node.Store = store2
+
+ pr5, pw5 := io.Pipe()
+ serverStream3 := &mockStream{r: pr5, w: io.Discard, protocol: protocol.ID("/sam/auth/1.0.0")}
+
+ go func() {
+ node.HandleAuthHandshake(serverStream3)
+ }()
+
+ writer3 := msgio.NewVarintWriter(pw5)
+ if err := writer3.WriteMsg(envelopeBytes); err != nil {
+ t.Fatal(err)
+ }
+
+ time.Sleep(1 * time.Second)
+
+ _, err = store2.GetVerifiedIdentity(dummyPeer)
+ if err != nil {
+ t.Fatalf("Expected identity to be saved via cache hit, got err: %v", err)
+ }
+}
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 340aacfc..61e3cf38 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -17,12 +17,15 @@ package main
import (
"context"
"crypto/ed25519"
+ "crypto/sha256"
+ "encoding/hex"
"fmt"
"sync"
"time"
"github.com/biscuit-auth/biscuit-go/v2"
+ "github.com/biscuit-auth/biscuit-go/v2/parser"
"github.com/google/sam/api"
lru "github.com/hashicorp/golang-lru/v2"
"github.com/libp2p/go-libp2p"
@@ -238,6 +241,12 @@ func (n *SamNode) listenForHubEvents(ctx context.Context) {
continue
}
+ // Freshness check: reject events older than 5 minutes to prevent replay attacks
+ if time.Since(time.Unix(event.Timestamp, 0)) > 5*time.Minute {
+ logger.Warnf("[Mesh Event] Dropping stale event from %s (timestamp: %d)", msg.ReceivedFrom, event.Timestamp)
+ continue
+ }
+
n.mu.Lock()
switch event.Type {
case api.MeshEvent_JOIN:
@@ -414,6 +423,16 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {
return
}
+ // Check verification cache
+ tokenHash := sha256.Sum256(exchange.Biscuit)
+ hashStr := hex.EncodeToString(tokenHash[:])
+
+ cacheHit := false
+ if valid, ok := n.verificationCache.Get(hashStr); ok && valid {
+ logger.Infof("[AuthN] Token cache hit for %s", remotePeer)
+ cacheHit = true
+ }
+
// 2. Unmarshal and verify token format
b, err := biscuit.Unmarshal(exchange.Biscuit)
if err != nil {
@@ -421,20 +440,38 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {
return
}
- // 3. Verify signature chain against the trusted Hub keys.
- n.keysMu.RLock()
- keys := n.trustedKeys
- n.keysMu.RUnlock()
+ authorized := false
+ if cacheHit {
+ authorized = true
+ } else {
+ // 3. Verify signature chain against the trusted Hub keys.
+ n.keysMu.RLock()
+ keys := n.trustedKeys
+ n.keysMu.RUnlock()
- var authorized bool
- for _, tk := range keys {
- authorizer, err := b.Authorizer(tk.Key)
- if err != nil {
- continue
+ for _, tk := range keys {
+ authorizer, err := b.Authorizer(tk.Key)
+ if err != nil {
+ continue
+ }
+
+ // Admission only requires a valid signature, so allow if true
+ rule, err := parser.FromStringPolicy("allow if true")
+ if err != nil {
+ logger.Errorf("[AuthN] Failed to parse rule: %v", err)
+ continue
+ }
+ authorizer.AddPolicy(rule)
+
+ if err := authorizer.Authorize(); err == nil {
+ authorized = true
+ break
+ }
}
- if err := authorizer.Authorize(); err == nil {
- authorized = true
- break
+
+ if authorized {
+ // Cache successful verification
+ n.verificationCache.Add(hashStr, true)
}
}