Skip to content

Agent Mesh

fix(node): adopt recovered router addresses and validate stored key sizes

Antonio Ojea649dbf5fe559
diff --git a/internal/node/enroll_test.go b/internal/node/enroll_test.go
index f80ee015..ca6e8fbb 100644
--- a/internal/node/enroll_test.go
+++ b/internal/node/enroll_test.go
@@ -30,11 +30,53 @@ import (
"github.com/biscuit-auth/biscuit-go/v2"
"github.com/google/sam/api"
"github.com/google/sam/internal/identity"
+ "github.com/libp2p/go-libp2p"
"github.com/libp2p/go-libp2p/core/crypto"
+ "github.com/libp2p/go-libp2p/core/network"
"github.com/libp2p/go-libp2p/core/peer"
+ "github.com/libp2p/go-msgio"
"google.golang.org/protobuf/proto"
)
+// startMockRouterWithKey runs a minimal router whose auth response biscuit is
+// signed by the given CP key, so nodes trusting that key can authenticate.
+func startMockRouterWithKey(t *testing.T, cpPriv ed25519.PrivateKey, role string) string {
+ t.Helper()
+ h, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
+ if err != nil {
+ t.Fatalf("failed to create mock router host: %v", err)
+ }
+ t.Cleanup(func() { _ = h.Close() })
+
+ builder := biscuit.NewBuilder(cpPriv)
+ for _, f := range []biscuit.Fact{
+ {Predicate: biscuit.Predicate{Name: api.FactNode, IDs: []biscuit.Term{biscuit.String(h.ID().String())}}},
+ {Predicate: biscuit.Predicate{Name: api.FactRole, IDs: []biscuit.Term{biscuit.String(role)}}},
+ {Predicate: biscuit.Predicate{Name: api.FactExpiration, IDs: []biscuit.Term{biscuit.Date(time.Now().Add(24 * time.Hour))}}},
+ {Predicate: biscuit.Predicate{Name: api.FactTargetUnrestricted}},
+ } {
+ if err := builder.AddAuthorityFact(f); err != nil {
+ t.Fatalf("failed to add router fact: %v", err)
+ }
+ }
+ tok, err := builder.Build()
+ if err != nil {
+ t.Fatalf("failed to build router biscuit: %v", err)
+ }
+ routerBiscuit, err := tok.Serialize()
+ if err != nil {
+ t.Fatalf("failed to serialize router biscuit: %v", err)
+ }
+
+ h.SetStreamHandler(api.AuthProtocolID, func(s network.Stream) {
+ defer func() { _ = s.Close() }()
+ data, _ := proto.Marshal(&api.AuthResponse{Success: true, Biscuit: routerBiscuit})
+ _ = msgio.NewVarintWriter(s).WriteMsg(data)
+ })
+
+ return h.Addrs()[0].String() + "/p2p/" + h.ID().String()
+}
+
// TestStartRecoversStaleIdentityViaRefreshToken covers #321: a stored
// identity signed by a fully rotated-out key must heal at startup through
// refresh grant + HTTP re-enrollment, keeping the PeerID, instead of fataling.
@@ -42,6 +84,8 @@ func TestStartRecoversStaleIdentityViaRefreshToken(t *testing.T) {
cpPub, cpPriv, _ := ed25519.GenerateKey(nil)
_, stalePriv, _ := ed25519.GenerateKey(nil)
+ routerAddr := startMockRouterWithKey(t, cpPriv, api.RoleRouter)
+
store, err := NewStore(t.TempDir())
if err != nil {
t.Fatal(err)
@@ -125,7 +169,7 @@ func TestStartRecoversStaleIdentityViaRefreshToken(t *testing.T) {
resp := &api.EnrollResponse{
BiscuitToken: mint(cpPriv, req.PeerId),
ControlPlanePublicKey: cpPub,
- RouterAddresses: []string{"/ip4/127.0.0.1/tcp/1"},
+ RouterAddresses: []string{routerAddr},
Expiration: time.Now().Add(24 * time.Hour).Unix(),
}
data, _ := proto.Marshal(resp)
@@ -173,6 +217,12 @@ func TestStartRecoversStaleIdentityViaRefreshToken(t *testing.T) {
if err := identity.VerifyBiscuitRole(node.GetIdentity(), cpPub, api.RoleNode, time.Second); err != nil {
t.Errorf("recovered identity does not verify under the current CP key: %v", err)
}
+
+ // The router addresses from the re-enrollment must be adopted in-memory,
+ // not only persisted: the static relay setup runs right after recovery.
+ if len(node.config.RouterAddrs) != 1 || node.config.RouterAddrs[0].String() != routerAddr {
+ t.Errorf("recovered router addresses not adopted: got %v, want %s", node.config.RouterAddrs, routerAddr)
+ }
}
// Without a refresh token the startup failure must stay fatal.
diff --git a/internal/node/node.go b/internal/node/node.go
index 85d12e71..dab2b2b1 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -259,7 +259,15 @@ func NewSamNode(cfg Options) (*SamNode, error) {
if stored, err := cfg.Store.LoadTrustedKeys(); err != nil {
logger.Warnf("Failed to load persisted trusted keys: %v", err)
} else {
- trustedKeys = stored
+ for _, tk := range stored {
+ // A corrupt entry must not reach ed25519 verification (panics
+ // on wrong-size keys).
+ if len(tk.Key) == ed25519.PublicKeySize {
+ trustedKeys = append(trustedKeys, tk)
+ } else {
+ logger.Warnf("Ignoring persisted trusted key with invalid size %d", len(tk.Key))
+ }
+ }
}
}
if len(cfg.ControlPlanePubKey) > 0 && !containsTrustedKey(trustedKeys, cfg.ControlPlanePubKey) {
@@ -312,7 +320,7 @@ func (n *SamNode) Start(ctx context.Context) error {
}
n.keysMu.RUnlock()
if len(candidates) == 0 {
- if pubKeyBytes, _, err := n.Store.LoadMeshConfig(); err == nil && len(pubKeyBytes) > 0 {
+ if pubKeyBytes, _, err := n.Store.LoadMeshConfig(); err == nil && len(pubKeyBytes) == ed25519.PublicKeySize {
candidates = append(candidates, ed25519.PublicKey(pubKeyBytes))
}
}
@@ -332,6 +340,19 @@ func (n *SamNode) Start(ctx context.Context) error {
return fmt.Errorf("loaded identity fails role requirement %q (refresh-token recovery failed: %v): %w", n.config.RequiredRole, recErr, roleErr)
}
logger.Info("Identity recovered via refresh-token re-enrollment.")
+ // Re-enrollment persisted the response's router addresses; adopt
+ // them so the static relay setup below doesn't use stale ones.
+ if _, storedAddrs, loadErr := n.Store.LoadMeshConfig(); loadErr == nil {
+ var addrs []multiaddr.Multiaddr
+ for _, addrStr := range storedAddrs {
+ if ma, parseErr := multiaddr.NewMultiaddr(addrStr); parseErr == nil {
+ addrs = append(addrs, ma)
+ }
+ }
+ if len(addrs) > 0 {
+ n.config.RouterAddrs = addrs
+ }
+ }
}
}
}
diff --git a/internal/node/node_test.go b/internal/node/node_test.go
index b0177c07..d7df2458 100644
--- a/internal/node/node_test.go
+++ b/internal/node/node_test.go
@@ -188,6 +188,31 @@ func TestKeyRotationEventSurvivesRestart(t *testing.T) {
}
}
+func TestNewSamNodeIgnoresCorruptPersistedKeys(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = store.Close() }()
+
+ goodKey, _, _ := ed25519.GenerateKey(nil)
+ if err := store.SaveTrustedKeys([]TrustedKey{
+ {Key: []byte("corrupt"), ReceivedAt: time.Now()},
+ {Key: goodKey, ReceivedAt: time.Now()},
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ priv, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ node, err := NewSamNode(Options{PrivKey: priv, Store: store})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(node.trustedKeys) != 1 || !node.trustedKeys[0].Key.Equal(goodKey) {
+ t.Fatalf("expected only the valid key to survive loading, got %d keys", len(node.trustedKeys))
+ }
+}
+
// TestPruneTrustedKeys covers the trust-set floor: a node that runs past the
// grace period without witnessing a rotation must not age out its only key.
func TestPruneTrustedKeys(t *testing.T) {