Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
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.goindex 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.goindex 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.goindex 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) {