Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
fix peer Id aliasing bugs and normalise database records
Ibrahimfe411ce051cf
diff --git a/api/network.go b/api/network.goindex f073f5cb..f9a37f92 100644--- a/api/network.go+++ b/api/network.go@@ -23,6 +23,7 @@ import ("strings""time"+ "github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/core/protocol")@@ -76,6 +77,14 @@ const (TokenRefreshCheckInterval = 10 * time.Minute)+func CanonicalPeerID(s string) (string, error) {+ p, err := peer.Decode(s)+ if err != nil {+ return "", err+ }+ return p.String(), nil+}+// EnrollChallenge is the payload a bootstrap enrollee signs to prove// possession of the private half of BootstrapEnrollRequest.public_key at// POST /enroll, carried in that message's timestamp/challenge_signaturediff --git a/internal/controlplane/mesh.go b/internal/controlplane/mesh.goindex 0f708bde..02131f45 100644--- a/internal/controlplane/mesh.go+++ b/internal/controlplane/mesh.go@@ -139,7 +139,7 @@ func (p *P2PMeshAdapter) PublishEvent(ctx context.Context, eventType api.MeshEveevent := &api.MeshEvent{Type: eventType,- PeerId: peerID,+ PeerId: canonicalPeerID(peerID),Timestamp: time.Now().UnixMilli(),NewPublicKey: payload,}@@ -165,6 +165,17 @@ func (p *P2PMeshAdapter) PublishEvent(ctx context.Context, eventType api.MeshEvereturn nil}+func canonicalPeerID(peerID string) string {+ if peerID == "" {+ return ""+ }+ canonical, err := api.CanonicalPeerID(peerID)+ if err != nil {+ return peerID+ }+ return canonical+}+func (p *P2PMeshAdapter) DiscoverServices(ctx context.Context, serviceType string) ([]*ServiceAnnouncement, error) {return nil, nil}diff --git a/internal/controlplane/peer_id_canonicalization_test.go b/internal/controlplane/peer_id_canonicalization_test.gonew file mode 100644index 00000000..55addb59--- /dev/null+++ b/internal/controlplane/peer_id_canonicalization_test.go@@ -0,0 +1,368 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package controlplane++import (+ "bytes"+ "context"+ "encoding/base64"+ "net/http"+ "strconv"+ "sync"+ "testing"+ "time"++ "github.com/google/sam/api"+ "github.com/google/sam/internal/storage"+ "github.com/libp2p/go-libp2p/core/crypto"+ "github.com/libp2p/go-libp2p/core/peer"+ "google.golang.org/protobuf/proto"+)++func cidAlias(t *testing.T, id peer.ID) string {+ t.Helper()+ alias := peer.ToCid(id).String()+ if alias == id.String() {+ t.Fatalf("peer.ToCid(%s) did not produce a second spelling", id)+ }+ decoded, err := peer.Decode(alias)+ if err != nil {+ t.Fatalf("alias %q does not decode: %v", alias, err)+ }+ if decoded != id {+ t.Fatalf("alias %q decodes to %s, want %s", alias, decoded, id)+ }+ return alias+}++func newTestKey(t *testing.T) (crypto.PrivKey, peer.ID) {+ t.Helper()+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)+ if err != nil {+ t.Fatalf("failed to generate key: %v", err)+ }+ id, err := peer.IDFromPrivateKey(priv)+ if err != nil {+ t.Fatalf("failed to derive peer id: %v", err)+ }+ return priv, id+}++type recordingMesh struct {+ mu sync.Mutex+ banned []string+}++func (m *recordingMesh) PublishEvent(ctx context.Context, eventType api.MeshEvent_Type, peerID string, payload []byte) error {+ m.mu.Lock()+ defer m.mu.Unlock()+ if eventType == api.MeshEvent_BANNED {+ m.banned = append(m.banned, peerID)+ }+ return nil+}++func (m *recordingMesh) DiscoverServices(ctx context.Context, serviceType string) ([]*ServiceAnnouncement, error) {+ return nil, nil+}++func (m *recordingMesh) GetNodeStatus(ctx context.Context, peerID string) (*NodeStatus, error) {+ return nil, nil+}++func (m *recordingMesh) Close() error {+ return nil+}++func (m *recordingMesh) bannedPeers() []string {+ m.mu.Lock()+ defer m.mu.Unlock()+ return append([]string(nil), m.banned...)+}++func enrollNodeRow(t *testing.T, store storage.Store, peerID string, pubKey []byte, ownerID string) {+ t.Helper()+ err := store.EnrollNode(context.Background(), &storage.EnrolledNode{+ PeerID: peerID,+ PublicKey: pubKey,+ Biscuit: []byte("biscuit"),+ Role: api.RoleNode,+ OwnerID: ownerID,+ ExpiresAt: time.Now().Add(time.Hour),+ })+ if err != nil {+ t.Fatalf("failed to enroll node %q: %v", peerID, err)+ }+}++func TestBannedNodeCannotRegisterUnderAnAlias(t *testing.T) {+ issuer, mintToken := startCustomMockOIDC(t)+ srv, store, baseURL := setupTestServer(t, issuer)+ defer func() {+ _ = srv.Close()+ _ = store.Close()+ }()+ srv.config.AdminToken = "super-secret-admin-token"++ ctx := context.Background()+ client := &http.Client{Timeout: 5 * time.Second}++ if err := store.SaveMeshPolicy(ctx, nil, []*api.PolicyBinding{+ {Role: api.RoleNode, Members: []string{api.SystemAuthenticated}},+ }); err != nil {+ t.Fatal(err)+ }++ register := func(t *testing.T, priv crypto.PrivKey, peerID, sub string) int {+ t.Helper()+ pubBytes, err := crypto.MarshalPublicKey(priv.GetPublic())+ if err != nil {+ t.Fatal(err)+ }+ reqData, _ := proto.Marshal(&api.EnrollRequest{+ Jwt: mintToken(map[string]interface{}{"sub": sub}),+ PeerId: peerID,+ PublicKey: pubBytes,+ RequestedRole: api.RoleNode,+ })+ resp, err := client.Post(baseURL+"/register", "application/x-protobuf", bytes.NewReader(reqData))+ if err != nil {+ t.Fatalf("/register failed: %v", err)+ }+ defer func() { _ = resp.Body.Close() }()+ return resp.StatusCode+ }++ priv, id := newTestKey(t)+ alias := cidAlias(t, id)++ if status := register(t, priv, id.String(), "alias-attacker"); status != http.StatusOK {+ t.Fatalf("initial registration: got %d, want 200", status)+ }+ if _, err := store.GetNode(ctx, id.String()); err != nil {+ t.Fatalf("node was not stored under its canonical id: %v", err)+ }++ revokeData, _ := proto.Marshal(&api.TokenRevokeRequest{PeerId: id.String()})+ req, _ := http.NewRequest(http.MethodPost, baseURL+"/admin/revoke", bytes.NewReader(revokeData))+ req.Header.Set("Authorization", "Bearer super-secret-admin-token")+ resp, err := client.Do(req)+ if err != nil {+ t.Fatalf("/admin/revoke failed: %v", err)+ }+ _ = resp.Body.Close()+ if resp.StatusCode != http.StatusOK {+ t.Fatalf("/admin/revoke: got %d, want 200", resp.StatusCode)+ }++ if status := register(t, priv, alias, "alias-attacker"); status != http.StatusForbidden {+ t.Errorf("re-registration under an alias: got %d, want 403", status)+ }+ if status := register(t, priv, alias, "a-brand-new-identity"); status != http.StatusForbidden {+ t.Errorf("re-registration under an alias with a fresh identity: got %d, want 403", status)+ }+ if _, err := store.GetNode(ctx, alias); err != storage.ErrNotFound {+ t.Errorf("the alias grew a row of its own: err = %v", err)+ }++ otherPriv, otherID := newTestKey(t)+ if status := register(t, otherPriv, cidAlias(t, otherID), "somebody-else"); status != http.StatusOK {+ t.Errorf("unbanned identity under an alias: got %d, want 200", status)+ }+ if _, err := store.GetNode(ctx, otherID.String()); err != nil {+ t.Errorf("unbanned identity was not stored under its canonical id: %v", err)+ }+}++func TestRevokeBansTheIdentityNotTheSpelling(t *testing.T) {+ cases := []struct {+ name string+ revoke func(t *testing.T, baseURL, peerID, userToken, adminToken string, client *http.Client) int+ }{+ {+ name: "admin revoke",+ revoke: func(t *testing.T, baseURL, peerID, userToken, adminToken string, client *http.Client) int {+ t.Helper()+ body, _ := proto.Marshal(&api.TokenRevokeRequest{PeerId: peerID})+ req, _ := http.NewRequest(http.MethodPost, baseURL+"/admin/revoke", bytes.NewReader(body))+ req.Header.Set("Authorization", "Bearer "+adminToken)+ resp, err := client.Do(req)+ if err != nil {+ t.Fatalf("/admin/revoke failed: %v", err)+ }+ defer func() { _ = resp.Body.Close() }()+ return resp.StatusCode+ },+ },+ {+ name: "user revoke",+ revoke: func(t *testing.T, baseURL, peerID, userToken, adminToken string, client *http.Client) int {+ t.Helper()+ req, _ := http.NewRequest(http.MethodPost, baseURL+"/user/revoke?id="+peerID, nil)+ req.Header.Set("Authorization", "Bearer "+userToken)+ resp, err := client.Do(req)+ if err != nil {+ t.Fatalf("/user/revoke failed: %v", err)+ }+ defer func() { _ = resp.Body.Close() }()+ return resp.StatusCode+ },+ },+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ issuer, mintToken := startCustomMockOIDC(t)+ srv, store, baseURL := setupTestServer(t, issuer)+ defer func() {+ _ = srv.Close()+ _ = store.Close()+ }()+ srv.config.AdminToken = "super-secret-admin-token"++ mesh := &recordingMesh{}+ srv.SetMeshAdapter(mesh)++ ctx := context.Background()+ client := &http.Client{Timeout: 5 * time.Second}++ user := &storage.User{+ ID: "owner-sub",+ Email: "[email protected]",+ Role: "user",+ CreatedAt: time.Now(),+ }+ if err := store.SaveUser(ctx, user); err != nil {+ t.Fatalf("failed to save user: %v", err)+ }++ priv, id := newTestKey(t)+ alias := cidAlias(t, id)+ pubBytes, err := crypto.MarshalPublicKey(priv.GetPublic())+ if err != nil {+ t.Fatal(err)+ }+ enrollNodeRow(t, store, id.String(), pubBytes, user.ID)++ token := mintToken(map[string]interface{}{+ "iss": issuer,+ "sub": user.ID,+ "email": user.Email,+ "aud": "sam-mesh-audience",+ })+ if status := tc.revoke(t, baseURL, alias, token, "super-secret-admin-token", client); status != http.StatusOK {+ t.Fatalf("revoking through an alias: got %d, want 200", status)+ }++ node, err := store.GetNode(ctx, id.String())+ if err != nil {+ t.Fatalf("canonical row is gone: %v", err)+ }+ if !node.Banned {+ t.Error("the ban did not land on the identity the alias names")+ }+ if _, err := store.GetNode(ctx, alias); err != storage.ErrNotFound {+ t.Errorf("the revoke created a row under the alias: err = %v", err)+ }++ banned := mesh.bannedPeers()+ if len(banned) != 1 {+ t.Fatalf("published %d BANNED events, want 1: %v", len(banned), banned)+ }+ if banned[0] != id.String() {+ t.Errorf("BANNED event names %q, want the canonical %q", banned[0], id.String())+ }+ })+ }+}++func TestEnrollStatusReachesTheRecordThroughAnAlias(t *testing.T) {+ issuer, _ := startCustomMockOIDC(t)+ srv, store, baseURL := setupTestServer(t, issuer)+ defer func() {+ _ = srv.Close()+ _ = store.Close()+ }()++ ctx := context.Background()+ client := &http.Client{Timeout: 5 * time.Second}++ priv, id := newTestKey(t)+ alias := cidAlias(t, id)+ pubBytes, err := crypto.MarshalPublicKey(priv.GetPublic())+ if err != nil {+ t.Fatal(err)+ }+ if err := store.CreateEnrollmentRequest(ctx, &storage.EnrollmentRequest{+ ID: "req-1",+ PeerID: id.String(),+ PublicKey: pubBytes,+ TokenID: "token-1",+ Status: api.EnrollmentStatus_ENROLLMENT_STATUS_PENDING,+ CreatedAt: time.Now(),+ }); err != nil {+ t.Fatalf("failed to create enrollment request: %v", err)+ }++ status := func(t *testing.T, query, signed string) int {+ t.Helper()+ ts := time.Now().UnixMilli()+ sig, err := priv.Sign(api.EnrollStatusChallenge(signed, ts))+ if err != nil {+ t.Fatalf("failed to sign challenge: %v", err)+ }+ req, _ := http.NewRequest(http.MethodGet, baseURL+"/enroll/status?peer_id="+query, nil)+ req.Header.Set(api.HeaderChallengeTimestamp, strconv.FormatInt(ts, 10))+ req.Header.Set(api.HeaderChallengeSignature, base64.RawURLEncoding.EncodeToString(sig))+ resp, err := client.Do(req)+ if err != nil {+ t.Fatalf("/enroll/status failed: %v", err)+ }+ defer func() { _ = resp.Body.Close() }()+ return resp.StatusCode+ }++ if got := status(t, id.String(), id.String()); got != http.StatusOK {+ t.Errorf("canonical poll: got %d, want 200", got)+ }+ if got := status(t, alias, id.String()); got != http.StatusOK {+ t.Errorf("poll through an alias: got %d, want 200", got)+ }+ if got := status(t, alias, alias); got != http.StatusUnauthorized {+ t.Errorf("challenge signed over the alias: got %d, want 401", got)+ }+}++func TestCanonicalPeerIDIsBestEffort(t *testing.T) {+ _, id := newTestKey(t)+ alias := cidAlias(t, id)++ for _, tc := range []struct {+ name string+ in string+ want string+ }{+ {name: "canonical id is stable", in: id.String(), want: id.String()},+ {name: "alias folds to canonical", in: alias, want: id.String()},+ {name: "empty stays empty", in: "", want: ""},+ {name: "undecodable passes through", in: "peer-node-a", want: "peer-node-a"},+ } {+ t.Run(tc.name, func(t *testing.T) {+ if got := canonicalPeerID(tc.in); got != tc.want {+ t.Errorf("canonicalPeerID(%q) = %q, want %q", tc.in, got, tc.want)+ }+ })+ }+}diff --git a/internal/controlplane/server.go b/internal/controlplane/server.goindex 5f398ba9..94bd1e76 100644--- a/internal/controlplane/server.go+++ b/internal/controlplane/server.go@@ -483,25 +483,26 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {http.Error(w, "Invalid Peer ID", http.StatusBadRequest)return}+ canonical := pID.String()// A ban names the device key and the identity behind it; check both, or// a banned node re-enrolls from a freshly generated keypair.- if banned, err := s.store.IsNodeBanned(ctx, req.PeerId); err != nil {- logger.Errorf("Failed to check node ban for %s: %v", req.PeerId, err)+ if banned, err := s.store.IsNodeBanned(ctx, canonical); err != nil {+ logger.Errorf("Failed to check node ban for %s: %v", canonical, err)http.Error(w, "Internal server error", http.StatusInternalServerError)return} else if banned {- logger.Warnw("Banned node attempted enrollment", "peer_id", req.PeerId)+ logger.Warnw("Banned node attempted enrollment", "peer_id", canonical)http.Error(w, "Node is banned", http.StatusForbidden)return}if key := oidcIdentityKey(claims); key != "" {if banned, err := s.store.IsIdentityBanned(ctx, key); err != nil {- logger.Errorf("Failed to check identity ban for %s: %v", req.PeerId, err)+ logger.Errorf("Failed to check identity ban for %s: %v", canonical, err)http.Error(w, "Internal server error", http.StatusInternalServerError)return} else if banned {- logger.Warnw("Banned identity attempted enrollment", "peer_id", req.PeerId, "identity", key)+ logger.Warnw("Banned identity attempted enrollment", "peer_id", canonical, "identity", key)http.Error(w, "Identity is banned", http.StatusForbidden)return}@@ -536,7 +537,7 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {return}- resolvedRoles := resolveRoles(pID.String(), claims, bindings)+ resolvedRoles := resolveRoles(canonical, claims, bindings)var customAccessRoles []stringresolvedMap := make(map[string]bool)for _, r := range resolvedRoles {@@ -561,7 +562,7 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {// The node declared these labels itself, so they are only worth signing if// a role it resolves to says it may carry them.if err := api.LabelPatternsAllow(allowedLabelPatterns(finalRoles, policyRoles), req.Labels); err != nil {- logger.Warnw("Rejected undeclarable label at enrollment", "peer_id", req.PeerId, "error", err)+ logger.Warnw("Rejected undeclarable label at enrollment", "peer_id", canonical, "error", err)http.Error(w, "Label not permitted: "+err.Error(), http.StatusForbidden)return}@@ -583,7 +584,7 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {}biscuitData, _, err := identity.MintBiscuitToken(privKey, claims, token, pID, biscuitExpiry, finalRoles, policyRoles, req.Labels)if err != nil {- logger.Errorw("Biscuit minting failed", "peer_id", req.PeerId, "error", err)+ logger.Errorw("Biscuit minting failed", "peer_id", canonical, "error", err)http.Error(w, "Failed to mint biscuit: "+err.Error(), http.StatusForbidden)return}@@ -598,7 +599,7 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {}nodeRecord := &storage.EnrolledNode{- PeerID: req.PeerId,+ PeerID: canonical,PublicKey: req.PublicKey,Biscuit: biscuitData,Role: primaryRole,@@ -702,11 +703,12 @@ func (s *Server) HandleRefresh(w http.ResponseWriter, r *http.Request) {http.Error(w, "Invalid biscuit: "+err.Error(), http.StatusUnauthorized)return}+ canonical := pID.String()// Fetch node record- nodeRecord, err := s.store.GetNode(ctx, pID.String())+ nodeRecord, err := s.store.GetNode(ctx, canonical)if err == storage.ErrNotFound {- logger.Warnw("Node not found for refresh", "peer_id", pID.String())+ logger.Warnw("Node not found for refresh", "peer_id", canonical)http.Error(w, "Node not enrolled", http.StatusUnauthorized)return} else if err != nil {@@ -717,11 +719,11 @@ func (s *Server) HandleRefresh(w http.ResponseWriter, r *http.Request) {if err := nodeRecord.CheckAdmission(time.Now()); err != nil {if errors.Is(err, storage.ErrNodeBanned) {- logger.Warnw("Banned node attempted refresh", "peer_id", pID.String())+ logger.Warnw("Banned node attempted refresh", "peer_id", canonical)http.Error(w, "Node is banned", http.StatusForbidden)return}- logger.Warnw("Session expired for node", "peer_id", pID.String(), "expires_at", nodeRecord.ExpiresAt)+ logger.Warnw("Session expired for node", "peer_id", canonical, "expires_at", nodeRecord.ExpiresAt)http.Error(w, "Session expired, please re-enroll interactively", http.StatusUnauthorized)return}@@ -734,8 +736,8 @@ func (s *Server) HandleRefresh(w http.ResponseWriter, r *http.Request) {return}- if err := verifyFreshChallenge(pubKey, api.RefreshChallenge(nodeRecord.PeerID, req.Timestamp), req.Timestamp, req.ChallengeSignature); err != nil {- logger.Warnw("Refresh challenge verification failed", "peer_id", nodeRecord.PeerID, "error", err)+ if err := verifyFreshChallenge(pubKey, api.RefreshChallenge(canonical, req.Timestamp), req.Timestamp, req.ChallengeSignature); err != nil {+ logger.Warnw("Refresh challenge verification failed", "peer_id", canonical, "error", err)http.Error(w, "Challenge verification failed: "+err.Error(), http.StatusUnauthorized)return}@@ -780,7 +782,7 @@ func (s *Server) HandleRefresh(w http.ResponseWriter, r *http.Request) {http.Error(w, "Internal server error", http.StatusInternalServerError)return}- resolvedRoles := resolveRoles(pID.String(), claims, bindings)+ resolvedRoles := resolveRoles(canonical, claims, bindings)var customAccessRoles []stringresolvedMap := make(map[string]bool)for _, r := range resolvedRoles {@@ -904,6 +906,7 @@ func (s *Server) HandleRouterLease(w http.ResponseWriter, r *http.Request) {http.Error(w, "Invalid Peer ID", http.StatusBadRequest)return}+ canonical := pID.String()// Fetch all valid public keys from CP to authorize router biscuitvalidKeys, err := s.store.GetAllValidKeys(r.Context())@@ -921,7 +924,7 @@ func (s *Server) HandleRouterLease(w http.ResponseWriter, r *http.Request) {// Verify Biscuit and enforce expected remote peer idb, verifyingKey, err := identity.VerifyBiscuitAndGetKey(req.Biscuit, pID, cpPubKeys, s.config.BiscuitTimeout)if err != nil {- logger.Warnf("Router %s failed biscuit verification: %v", req.PeerId, err)+ logger.Warnf("Router %s failed biscuit verification: %v", canonical, err)http.Error(w, "Biscuit verification failed: "+err.Error(), http.StatusUnauthorized)return}@@ -943,7 +946,7 @@ func (s *Server) HandleRouterLease(w http.ResponseWriter, r *http.Request) {authorizer.AddPolicy(api.AllowIfTruePolicy)if err := authorizer.Authorize(); err != nil {- logger.Warnf("Router %s lacks router role in its biscuit: %v\nWorld state:\n%s", req.PeerId, err, authorizer.PrintWorld())+ logger.Warnf("Router %s lacks router role in its biscuit: %v\nWorld state:\n%s", canonical, err, authorizer.PrintWorld())http.Error(w, "Unauthorized: entity is not a router", http.StatusForbidden)return}@@ -951,7 +954,7 @@ func (s *Server) HandleRouterLease(w http.ResponseWriter, r *http.Request) {// A lease is what /info serves to every joining node, and biscuits stay// valid offline until their TTL: revocation has to cut off renewals here,// as /refresh and /policies already do.- routerRecord, err := s.store.GetNode(r.Context(), pID.String())+ routerRecord, err := s.store.GetNode(r.Context(), canonical)if err == storage.ErrNotFound {http.Error(w, "Router not enrolled", http.StatusUnauthorized)return@@ -962,11 +965,11 @@ func (s *Server) HandleRouterLease(w http.ResponseWriter, r *http.Request) {}if err := routerRecord.CheckAdmission(time.Now()); err != nil {if errors.Is(err, storage.ErrNodeBanned) {- logger.Warnw("Revoked router attempted lease renewal", "peer_id", pID.String())+ logger.Warnw("Revoked router attempted lease renewal", "peer_id", canonical)http.Error(w, "Router is banned", http.StatusForbidden)return}- logger.Warnw("Router with expired session attempted lease renewal", "peer_id", pID.String())+ logger.Warnw("Router with expired session attempted lease renewal", "peer_id", canonical)http.Error(w, "Session expired, please re-enroll", http.StatusUnauthorized)return}@@ -989,7 +992,7 @@ func (s *Server) HandleRouterLease(w http.ResponseWriter, r *http.Request) {// Expose lease renewalexpiresAt := time.Now().Add(s.config.LeaseDuration)lease := &storage.RouterLease{- PeerID: req.PeerId,+ PeerID: canonical,Addresses: req.Addresses,LastRenewal: time.Now(),ExpiresAt: expiresAt,@@ -1252,6 +1255,7 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {http.Error(w, "Invalid Peer ID", http.StatusBadRequest)return}+ canonical := pID.String()// Proof of possession: peer_id must be the submitted key's own, and the// caller must hold its private half. This gates the existing-request@@ -1263,12 +1267,12 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {return}if !pID.MatchesPublicKey(enrolleeKey) {- logger.Warnw("Enrollment peer_id does not match public_key", "peer_id", req.PeerId)+ logger.Warnw("Enrollment peer_id does not match public_key", "peer_id", canonical)s.writeEnrollError(w, api.EnrollmentStatus_ENROLLMENT_STATUS_REJECTED, "peer_id is not derived from public_key")return}- if err := verifyFreshChallenge(enrolleeKey, api.EnrollChallenge(req.PeerId, req.Timestamp), req.Timestamp, req.ChallengeSignature); err != nil {- logger.Warnw("Enroll challenge verification failed", "peer_id", req.PeerId, "error", err)+ if err := verifyFreshChallenge(enrolleeKey, api.EnrollChallenge(canonical, req.Timestamp), req.Timestamp, req.ChallengeSignature); err != nil {+ logger.Warnw("Enroll challenge verification failed", "peer_id", canonical, "error", err)s.writeEnrollError(w, api.EnrollmentStatus_ENROLLMENT_STATUS_REJECTED, "Invalid enrollment challenge: "+err.Error())return}@@ -1276,18 +1280,18 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {// Bootstrap enrollments carry no OIDC identity, but the device-key ban// still applies, and before the existing-request lookup: a banned node// must not replay its old approved enrollment either.- if banned, err := s.store.IsNodeBanned(ctx, req.PeerId); err != nil {- logger.Errorf("Failed to check node ban for %s: %v", req.PeerId, err)+ if banned, err := s.store.IsNodeBanned(ctx, canonical); err != nil {+ logger.Errorf("Failed to check node ban for %s: %v", canonical, err)http.Error(w, "Internal server error", http.StatusInternalServerError)return} else if banned {- logger.Warnw("Banned node attempted bootstrap enrollment", "peer_id", req.PeerId)+ logger.Warnw("Banned node attempted bootstrap enrollment", "peer_id", canonical)s.writeEnrollError(w, api.EnrollmentStatus_ENROLLMENT_STATUS_REJECTED, "Node is banned")return}// 2. Check for existing enrollment request- existingReq, err := s.store.GetEnrollmentRequest(ctx, req.PeerId)+ existingReq, err := s.store.GetEnrollmentRequest(ctx, canonical)if err == nil {// Request already exists, return statusvar resp *api.BootstrapEnrollResponse@@ -1315,7 +1319,7 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {// 3. Create new enrollment requestenrollReq := &storage.EnrollmentRequest{ID: cryptoRandUUID(),- PeerID: req.PeerId,+ PeerID: canonical,PublicKey: req.PublicKey,TokenID: tokenRecord.ID,Status: api.EnrollmentStatus_ENROLLMENT_STATUS_PENDING,@@ -1345,7 +1349,7 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {// allowed_labels is the only thing standing between a self-declared// label and a signed one. Manual approval attests them separately.if err := api.LabelPatternsAllow(allowedLabelPatterns([]string{tokenRecord.Role}, policyRoles), req.Labels); err != nil {- logger.Warnw("Rejected undeclarable label at bootstrap enrollment", "peer_id", req.PeerId, "error", err)+ logger.Warnw("Rejected undeclarable label at bootstrap enrollment", "peer_id", canonical, "error", err)s.writeEnrollError(w, api.EnrollmentStatus_ENROLLMENT_STATUS_REJECTED, "Label not permitted: "+err.Error())return}@@ -1369,7 +1373,7 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {}nodeRecord := &storage.EnrolledNode{- PeerID: req.PeerId,+ PeerID: canonical,PublicKey: req.PublicKey,Biscuit: biscuitBytes,Role: tokenRecord.Role,@@ -1471,8 +1475,10 @@ func (s *Server) HandleEnrollStatus(w http.ResponseWriter, r *http.Request) {return}+ canonical := canonicalPeerID(peerID)+ctx := r.Context()- enrollReq, err := s.store.GetEnrollmentRequest(ctx, peerID)+ enrollReq, err := s.store.GetEnrollmentRequest(ctx, canonical)if err == storage.ErrNotFound {http.Error(w, "Unauthorized", http.StatusUnauthorized)return@@ -1484,12 +1490,12 @@ func (s *Server) HandleEnrollStatus(w http.ResponseWriter, r *http.Request) {pubKey, err := crypto.UnmarshalPublicKey(enrollReq.PublicKey)if err != nil {- logger.Errorf("Corrupted public key stored for enrollment %s: %v", peerID, err)+ logger.Errorf("Corrupted public key stored for enrollment %s: %v", canonical, err)http.Error(w, "Unauthorized", http.StatusUnauthorized)return}- if err := verifyFreshChallenge(pubKey, api.EnrollStatusChallenge(peerID, ts), ts, sig); err != nil {- logger.Warnw("Enroll status challenge verification failed", "peer_id", peerID, "error", err)+ if err := verifyFreshChallenge(pubKey, api.EnrollStatusChallenge(canonical, ts), ts, sig); err != nil {+ logger.Warnw("Enroll status challenge verification failed", "peer_id", canonical, "error", err)http.Error(w, "Unauthorized", http.StatusUnauthorized)return}@@ -1754,6 +1760,7 @@ func (s *Server) HandleAdminEnrollmentAction(w http.ResponseWriter, r *http.Requhttp.Error(w, "Invalid Peer ID stored in request", http.StatusInternalServerError)return}+ canonical := pID.String()// No policy fetch needed.@@ -1796,7 +1803,7 @@ func (s *Server) HandleAdminEnrollmentAction(w http.ResponseWriter, r *http.Requ}nodeRecord := &storage.EnrolledNode{- PeerID: enrollReq.PeerID,+ PeerID: canonical,PublicKey: enrollReq.PublicKey,Biscuit: biscuitBytes,Role: tokenRecord.Role,@@ -1854,8 +1861,10 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {return}+ canonical := canonicalPeerID(req.PeerId)+// Retrieve the node from storage to verify it exists- node, err := s.store.GetNode(ctx, req.PeerId)+ node, err := s.store.GetNode(ctx, canonical)if err == storage.ErrNotFound {http.Error(w, "Node not found", http.StatusNotFound)return@@ -1866,13 +1875,13 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {}if err := s.banNode(ctx, node); err != nil {- logger.Errorf("Failed to ban/revoke node %s: %v", req.PeerId, err)+ logger.Errorf("Failed to ban/revoke node %s: %v", canonical, err)http.Error(w, "Internal server error", http.StatusInternalServerError)return}- if err := s.getMeshAdapter().PublishEvent(ctx, api.MeshEvent_BANNED, req.PeerId, nil); err != nil {- logger.Warnf("Failed to publish BANNED event for node %s to mesh: %v", req.PeerId, err)+ if err := s.getMeshAdapter().PublishEvent(ctx, api.MeshEvent_BANNED, node.PeerID, nil); err != nil {+ logger.Warnf("Failed to publish BANNED event for node %s to mesh: %v", node.PeerID, err)}resp := &api.TokenRevokeResponse{@@ -2125,8 +2134,10 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {return}+ canonical := canonicalPeerID(peerID)+ctx := r.Context()- node, err := s.store.GetNode(ctx, peerID)+ node, err := s.store.GetNode(ctx, canonical)if err == storage.ErrNotFound {http.Error(w, "Node not found", http.StatusNotFound)return@@ -2148,8 +2159,8 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {return}- if err := s.getMeshAdapter().PublishEvent(ctx, api.MeshEvent_BANNED, peerID, nil); err != nil {- logger.Warnf("Failed to publish BANNED event for node %s to mesh: %v", peerID, err)+ if err := s.getMeshAdapter().PublishEvent(ctx, api.MeshEvent_BANNED, node.PeerID, nil); err != nil {+ logger.Warnf("Failed to publish BANNED event for node %s to mesh: %v", node.PeerID, err)}w.WriteHeader(http.StatusOK)diff --git a/internal/node/discovery/discovery_test.go b/internal/node/discovery/discovery_test.goindex e329dd3b..936b9650 100644--- a/internal/node/discovery/discovery_test.go+++ b/internal/node/discovery/discovery_test.go@@ -293,3 +293,46 @@ func TestValidateServiceAnnounceCaps(t *testing.T) {})}}++func TestObserveKeysOnTheCanonicalPeerID(t *testing.T) {+ d := New(nil, testPeerID(t))+ signer := testPeerID(t)++ alias := peer.ToCid(signer).String()+ if alias == signer.String() {+ t.Fatal("peer.ToCid did not produce a second spelling of the signer")+ }+ spellings := []string{signer.String(), alias}+ for _, spelling := range spellings {+ decoded, err := peer.Decode(spelling)+ if err != nil || decoded != signer {+ t.Fatalf("%q does not decode to the signer (err %v)", spelling, err)+ }+ }++ announce := func(spelling string) {+ t.Helper()+ d.observe(rawMessage(t, signer, &api.ServiceAnnounce{+ PeerId: spelling, Type: api.ServiceType_SERVICE_TYPE_INFERENCE,+ ServiceName: "llm", Keys: []string{"m1"},+ Labels: map[string]string{"region": "eu"},+ Timestamp: time.Now().Unix(),+ }))+ }++ for _, spelling := range spellings {+ announce(spelling)+ if got := len(d.providers); got != 1 {+ t.Fatalf("after announcing as %q: got %d providers, want 1: %+v", spelling, got, d.providers)+ }+ for key, p := range d.providers {+ if p.PeerID != signer.String() {+ t.Errorf("provider keyed %q carries peer id %q, want %q", key, p.PeerID, signer.String())+ }+ }+ }++ if got := d.PeerLabels(signer.String()); got["region"] != "eu" {+ t.Errorf("PeerLabels under the canonical id: got %v, want region=eu", got)+ }+}diff --git a/internal/node/discovery/view.go b/internal/node/discovery/view.goindex 633d5dc0..bc4e6cfe 100644--- a/internal/node/discovery/view.go+++ b/internal/node/discovery/view.go@@ -127,7 +127,8 @@ func (d *Discovery) observe(msg *pubsub.Message) {}typeStr, _ := api.ServiceTypeToString(ann.GetType())- entryKey := ann.GetPeerId() + "|" + typeStr + "|" + ann.GetServiceName()+ signer := claimed.String()+ entryKey := signer + "|" + typeStr + "|" + ann.GetServiceName()d.viewMu.Lock()defer d.viewMu.Unlock()@@ -135,7 +136,7 @@ func (d *Discovery) observe(msg *pubsub.Message) {d.evictOldestLocked()}d.providers[entryKey] = Provider{- PeerID: ann.GetPeerId(),+ PeerID: signer,Type: ann.GetType(),Service: ann.GetServiceName(),Keys: ann.GetKeys(),diff --git a/internal/node/gate_test.go b/internal/node/gate_test.goindex b67d06e5..8b8e87b7 100644--- a/internal/node/gate_test.go+++ b/internal/node/gate_test.go@@ -98,8 +98,22 @@ func TestConnectionGater(t *testing.T) {// node would enforce no ban at all until the next MeshEvent_BANNED, which for// a ban published while it was down never arrives.func TestGaterEnforcesSeededBans(t *testing.T) {- priv, _, _ := crypto.GenerateEd25519Key(nil)- banned, err := peer.IDFromPrivateKey(priv)+ dir := t.TempDir()+ store, err := NewStore(dir)+ if err != nil {+ t.Fatal(err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Logf("failed to close store: %v", err)+ }+ }()++ bannedPriv, _, err := crypto.GenerateEd25519Key(nil)+ if err != nil {+ t.Fatal(err)+ }+ banned, err := peer.IDFromPrivateKey(bannedPriv)if err != nil {t.Fatal(err)}@@ -109,13 +123,14 @@ func TestGaterEnforcesSeededBans(t *testing.T) {t.Fatal(err)}- cache, err := lru.New[string, int64](100)+ node, err := NewSamNode(Options{+ PrivKey: bannedPriv,+ Store: store,+ BannedPeerIDs: []string{peer.ToCid(banned).String(), "not-a-peer-id"},+ })if err != nil {- t.Fatal(err)+ t.Fatalf("a ban set with an undecodable entry must not fail startup: %v", err)}- node := &SamNode{revokedPeers: cache}- // Mirrors what NewSamNode does with Options.BannedPeerIDs.- node.revokedPeers.Add(banned.String(), time.Now().Unix())gater := &nodeConnGate{node: node}if gater.InterceptPeerDial(banned) {diff --git a/internal/node/node.go b/internal/node/node.goindex c67c296f..20ea1d04 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().Unix())}node.peerLabelGate, err = lru.New[string, time.Time](labelGateCacheSize)if err != nil {@@ -1292,18 +1293,20 @@ func (n *SamNode) handleBannedEvent(event *api.MeshEvent) {logger.Infow("[Mesh Event] peer banned", "event", meshEventBanned, "peer", event.PeerId)+ p, err := peer.Decode(event.PeerId)+ if err != nil {+ return+ }if n.revokedPeers != nil {- n.revokedPeers.Add(event.PeerId, event.Timestamp)+ n.revokedPeers.Add(p.String(), 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.goindex 6f2ad09c..44dc1074 100644--- a/internal/node/node_test.go+++ b/internal/node/node_test.go@@ -105,22 +105,34 @@ func TestAnnounceFilter(t *testing.T) {}func TestHandleBannedEvent(t *testing.T) {- revokedCache, _ := lru.New[string, int64](10)- node := &SamNode{- revokedPeers: revokedCache,- BiscuitTimeout: 500 * time.Millisecond,+ priv, _, err := crypto.GenerateEd25519Key(nil)+ if err != nil {+ t.Fatal(err)}-- event := &api.MeshEvent{- Type: api.MeshEvent_BANNED,- PeerId: "12D3KooWAFv4iJst5G6MjwXhZ66K5zS1tP7A9vSg4vK8f1T7X8t9",- Timestamp: time.Now().UnixMilli(),+ banned, err := peer.IDFromPrivateKey(priv)+ if err != nil {+ t.Fatal(err)}- node.handleBannedEvent(event)+ for _, spelling := range []string{banned.String(), peer.ToCid(banned).String()} {+ revokedCache, _ := lru.New[string, int64](10)+ node := &SamNode{+ revokedPeers: revokedCache,+ BiscuitTimeout: 500 * time.Millisecond,+ }- if !node.revokedPeers.Contains(event.PeerId) {- t.Error("Expected peer to be added to revokedPeers")+ node.handleBannedEvent(&api.MeshEvent{+ Type: api.MeshEvent_BANNED,+ PeerId: spelling,+ Timestamp: time.Now().UnixMilli(),+ })++ if !node.revokedPeers.Contains(banned.String()) {+ t.Errorf("peer announced as %q is not revoked under its canonical id", spelling)+ }+ if gater := (&nodeConnGate{node: node}); gater.InterceptPeerDial(banned) {+ t.Errorf("peer announced as %q was not blocked by the gater", spelling)+ }}}diff --git a/internal/storage/peer_id_canonicalization_test.go b/internal/storage/peer_id_canonicalization_test.gonew file mode 100644index 00000000..7caa5233--- /dev/null+++ b/internal/storage/peer_id_canonicalization_test.go@@ -0,0 +1,395 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package storage++import (+ "context"+ "crypto/rand"+ "path/filepath"+ "testing"+ "time"++ "github.com/google/sam/api"+ libcrypto "github.com/libp2p/go-libp2p/core/crypto"+ "github.com/libp2p/go-libp2p/core/peer"+)++func newPeerID(t *testing.T) peer.ID {+ t.Helper()+ priv, _, err := libcrypto.GenerateEd25519Key(rand.Reader)+ if err != nil {+ t.Fatalf("failed to generate key: %v", err)+ }+ id, err := peer.IDFromPrivateKey(priv)+ if err != nil {+ t.Fatalf("failed to derive peer id: %v", err)+ }+ return id+}++func aliasOf(t *testing.T, id peer.ID) string {+ t.Helper()+ alias := peer.ToCid(id).String()+ if alias == id.String() {+ t.Fatalf("peer.ToCid(%s) did not produce an alias", id)+ }+ decoded, err := peer.Decode(alias)+ if err != nil {+ t.Fatalf("alias %q does not decode: %v", alias, err)+ }+ if decoded != id {+ t.Fatalf("alias %q decodes to %s, want %s", alias, decoded, id)+ }+ return alias+}++func openMigratedStore(t *testing.T, path string) *SQLStore {+ t.Helper()+ store, err := NewSQLStore("sqlite", path)+ if err != nil {+ t.Fatalf("failed to create store: %v", err)+ }+ if _, err := store.db.Exec(`DELETE FROM schema_migrations WHERE version = 9`); err != nil {+ t.Fatalf("failed to reset migration marker: %v", err)+ }+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ reopened, err := NewSQLStore("sqlite", path)+ if err != nil {+ t.Fatalf("failed to reopen store: %v", err)+ }+ t.Cleanup(func() { _ = reopened.Close() })+ return reopened+}++func newMigratableStore(t *testing.T) (*SQLStore, string) {+ t.Helper()+ path := filepath.Join(t.TempDir(), "test.db")+ store, err := NewSQLStore("sqlite", path)+ if err != nil {+ t.Fatalf("failed to create store: %v", err)+ }+ return store, path+}++func insertNodeRow(t *testing.T, s *SQLStore, peerID string, banned bool, enrolledAt int64) {+ t.Helper()+ _, err := s.db.Exec(+ `INSERT INTO nodes (peer_id, public_key, biscuit_token, role, enrollment_type, claims_json, owner_id, labels_json, enrolled_at, expires_at, banned)+ VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)`,+ peerID, []byte("public-key"), []byte("biscuit"), "node", "BOOTSTRAP", "", "{}", enrolledAt, enrolledAt, banned)+ if err != nil {+ t.Fatalf("failed to insert node %q: %v", peerID, err)+ }+}++func insertEnrollmentRequestRow(t *testing.T, s *SQLStore, id, peerID string, createdAt int64) {+ t.Helper()+ _, err := s.db.Exec(+ `INSERT INTO enrollment_requests (id, peer_id, public_key, token_id, status, labels_json, biscuit_token, created_at, resolved_at, resolved_by)+ VALUES (?, ?, ?, '', ?, '{}', NULL, ?, NULL, '')`,+ id, peerID, []byte("public-key"), 0, createdAt)+ if err != nil {+ t.Fatalf("failed to insert enrollment request %q: %v", id, err)+ }+}++func insertRouterRow(t *testing.T, s *SQLStore, peerID string, lastRenewal int64) {+ t.Helper()+ _, err := s.db.Exec(+ `INSERT INTO routers (peer_id, multiaddresses, last_lease_renewal, expires_at, connected_peers, dht_size)+ VALUES (?, '[]', ?, ?, '[]', 0)`,+ peerID, lastRenewal, time.Now().Add(time.Hour).UnixMilli())+ if err != nil {+ t.Fatalf("failed to insert router %q: %v", peerID, err)+ }+}++func TestMigrationRewritesAliasedPeerIDs(t *testing.T) {+ store, path := newMigratableStore(t)+ id := newPeerID(t)+ alias := aliasOf(t, id)++ insertNodeRow(t, store, alias, false, time.Now().UnixMilli())+ insertEnrollmentRequestRow(t, store, "req-1", alias, time.Now().UnixMilli())+ insertRouterRow(t, store, alias, time.Now().UnixMilli())+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ migrated := openMigratedStore(t, path)+ ctx := context.Background()++ node, err := migrated.GetNode(ctx, id.String())+ if err != nil {+ t.Fatalf("node not reachable under its canonical id: %v", err)+ }+ if node.PeerID != id.String() {+ t.Errorf("node peer id = %q, want %q", node.PeerID, id.String())+ }+ if _, err := migrated.GetNode(ctx, alias); err != ErrNotFound {+ t.Errorf("aliased node row survived: err = %v", err)+ }++ if _, err := migrated.GetEnrollmentRequest(ctx, id.String()); err != nil {+ t.Errorf("enrollment request not reachable under its canonical id: %v", err)+ }++ leases, err := migrated.GetActiveRouters(ctx)+ if err != nil {+ t.Fatalf("failed to list routers: %v", err)+ }+ if len(leases) != 1 || leases[0].PeerID != id.String() {+ t.Errorf("router leases = %+v, want a single lease for %s", leases, id.String())+ }+}++func TestMigrationKeepsBansAcrossSpellings(t *testing.T) {+ cases := []struct {+ name string+ aliasedBanned bool+ canonicalBanned bool+ wantBanned bool+ }{+ {name: "ban on the aliased row", aliasedBanned: true, canonicalBanned: false, wantBanned: true},+ {name: "ban on the canonical row", aliasedBanned: false, canonicalBanned: true, wantBanned: true},+ {name: "ban on both rows", aliasedBanned: true, canonicalBanned: true, wantBanned: true},+ {name: "no ban on either row", aliasedBanned: false, canonicalBanned: false, wantBanned: false},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ store, path := newMigratableStore(t)+ id := newPeerID(t)+ alias := aliasOf(t, id)++ insertNodeRow(t, store, alias, tc.aliasedBanned, time.Now().UnixMilli())+ insertNodeRow(t, store, id.String(), tc.canonicalBanned, time.Now().UnixMilli())+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ migrated := openMigratedStore(t, path)+ ctx := context.Background()++ nodes, err := migrated.ListNodes(ctx)+ if err != nil {+ t.Fatalf("failed to list nodes: %v", err)+ }+ if len(nodes) != 1 {+ t.Fatalf("got %d node rows, want the pair folded into one: %+v", len(nodes), nodes)+ }+ if nodes[0].PeerID != id.String() {+ t.Errorf("surviving row is keyed %q, want %q", nodes[0].PeerID, id.String())+ }++ banned, err := migrated.IsNodeBanned(ctx, id.String())+ if err != nil {+ t.Fatalf("failed to read ban: %v", err)+ }+ if banned != tc.wantBanned {+ t.Errorf("banned = %v, want %v", banned, tc.wantBanned)+ }+ })+ }+}++func TestMigrationKeepsNewestEnrollmentRequest(t *testing.T) {+ cases := []struct {+ name string+ aliasedCreated int64+ canonicalCreated int64+ wantID string+ }{+ {name: "aliased request is newer", aliasedCreated: 2000, canonicalCreated: 1000, wantID: "aliased"},+ {name: "canonical request is newer", aliasedCreated: 1000, canonicalCreated: 2000, wantID: "canonical"},+ {name: "same age favours the canonical row", aliasedCreated: 1000, canonicalCreated: 1000, wantID: "canonical"},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ store, path := newMigratableStore(t)+ id := newPeerID(t)+ alias := aliasOf(t, id)++ insertEnrollmentRequestRow(t, store, "aliased", alias, tc.aliasedCreated)+ insertEnrollmentRequestRow(t, store, "canonical", id.String(), tc.canonicalCreated)+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ migrated := openMigratedStore(t, path)+ ctx := context.Background()++ requests, err := migrated.ListEnrollmentRequests(ctx)+ if err != nil {+ t.Fatalf("failed to list enrollment requests: %v", err)+ }+ if len(requests) != 1 {+ t.Fatalf("got %d enrollment requests, want one: %+v", len(requests), requests)+ }+ if requests[0].ID != tc.wantID {+ t.Errorf("surviving request = %q, want %q", requests[0].ID, tc.wantID)+ }+ if requests[0].PeerID != id.String() {+ t.Errorf("surviving request peer id = %q, want %q", requests[0].PeerID, id.String())+ }+ })+ }+}++func TestMigrationKeepsNewestRouterLease(t *testing.T) {+ cases := []struct {+ name string+ aliasedRenewal int64+ canonicalRenewal int64+ wantRenewal int64+ }{+ {name: "aliased lease is newer", aliasedRenewal: 2000, canonicalRenewal: 1000, wantRenewal: 2000},+ {name: "canonical lease is newer", aliasedRenewal: 1000, canonicalRenewal: 2000, wantRenewal: 2000},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ store, path := newMigratableStore(t)+ id := newPeerID(t)+ alias := aliasOf(t, id)++ insertRouterRow(t, store, alias, tc.aliasedRenewal)+ insertRouterRow(t, store, id.String(), tc.canonicalRenewal)+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ migrated := openMigratedStore(t, path)++ leases, err := migrated.GetActiveRouters(context.Background())+ if err != nil {+ t.Fatalf("failed to list routers: %v", err)+ }+ if len(leases) != 1 {+ t.Fatalf("got %d router leases, want one: %+v", len(leases), leases)+ }+ if got := leases[0].LastRenewal.UnixMilli(); got != tc.wantRenewal {+ t.Errorf("surviving lease renewed at %d, want %d", got, tc.wantRenewal)+ }+ })+ }+}++func TestMigrationLeavesUndecodablePeerIDsAlone(t *testing.T) {+ store, path := newMigratableStore(t)+ for _, id := range []string{"peer-id-1", "peer-node-a", "not-a-peer-id"} {+ insertNodeRow(t, store, id, false, time.Now().UnixMilli())+ }+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ migrated := openMigratedStore(t, path)+ nodes, err := migrated.ListNodes(context.Background())+ if err != nil {+ t.Fatalf("failed to list nodes: %v", err)+ }+ if len(nodes) != 3 {+ t.Fatalf("got %d nodes, want the 3 undecodable rows untouched: %+v", len(nodes), nodes)+ }+}++func TestMigrationIsIdempotent(t *testing.T) {+ store, path := newMigratableStore(t)+ id := newPeerID(t)+ alias := aliasOf(t, id)+ insertNodeRow(t, store, alias, true, time.Now().UnixMilli())+ if err := store.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }++ first := openMigratedStore(t, path)+ if err := first.Close(); err != nil {+ t.Fatalf("failed to close store: %v", err)+ }+ second := openMigratedStore(t, path)++ ctx := context.Background()+ nodes, err := second.ListNodes(ctx)+ if err != nil {+ t.Fatalf("failed to list nodes: %v", err)+ }+ if len(nodes) != 1 || nodes[0].PeerID != id.String() {+ t.Fatalf("second run changed the rows: %+v", nodes)+ }+ banned, err := second.IsNodeBanned(ctx, id.String())+ if err != nil {+ t.Fatalf("failed to read ban: %v", err)+ }+ if !banned {+ t.Error("ban was lost on the second run")+ }+}++func TestMigrationRunsInTheCallersTransaction(t *testing.T) {+ store, _ := newMigratableStore(t)+ defer func() { _ = store.Close() }()++ id := newPeerID(t)+ alias := aliasOf(t, id)+ insertNodeRow(t, store, alias, true, time.Now().UnixMilli())++ tx, err := store.db.Begin()+ if err != nil {+ t.Fatalf("failed to begin transaction: %v", err)+ }+ if err := migrateCanonicalPeerIDs(context.Background(), store, tx); err != nil {+ t.Fatalf("migration failed: %v", err)+ }+ if err := tx.Rollback(); err != nil {+ t.Fatalf("failed to roll back: %v", err)+ }++ if _, err := store.GetNode(context.Background(), alias); err != nil {+ t.Fatalf("rollback did not restore the aliased row: %v", err)+ }+ if _, err := store.GetNode(context.Background(), id.String()); err != ErrNotFound {+ t.Errorf("canonical row exists after rollback: err = %v", err)+ }+}++func TestCanonicalPeerID(t *testing.T) {+ id := newPeerID(t)+ alias := aliasOf(t, id)++ canonical, err := api.CanonicalPeerID(alias)+ if err != nil {+ t.Fatalf("failed to canonicalize alias: %v", err)+ }+ if canonical != id.String() {+ t.Errorf("canonical = %q, want %q", canonical, id.String())+ }++ canonical, err = api.CanonicalPeerID(id.String())+ if err != nil {+ t.Fatalf("failed to canonicalize canonical id: %v", err)+ }+ if canonical != id.String() {+ t.Errorf("canonical form is not stable: %q", canonical)+ }++ if _, err := api.CanonicalPeerID("not-a-peer-id"); err == nil {+ t.Error("expected an error for an undecodable peer id")+ }+}diff --git a/internal/storage/sql_store.go b/internal/storage/sql_store.goindex 79291766..b2032f88 100644--- a/internal/storage/sql_store.go+++ b/internal/storage/sql_store.go@@ -113,9 +113,10 @@ func (s *SQLStore) isPostgres() bool {}type migration struct {- version int- sqlite []string- postgres []string+ version int+ sqlite []string+ postgres []string+ dataMigrate func(ctx context.Context, s *SQLStore, tx *sql.Tx) error}var migrations = []migration{@@ -369,6 +370,10 @@ var migrations = []migration{)`,},},+ {+ version: 9,+ dataMigrate: migrateCanonicalPeerIDs,+ },}func (s *SQLStore) initSchema() error {@@ -415,6 +420,12 @@ func (s *SQLStore) initSchemaDefault() error {}}+ if m.dataMigrate != nil {+ if err := m.dataMigrate(context.Background(), s, tx); err != nil {+ return fmt.Errorf("migration version %d data step failed: %w", m.version, err)+ }+ }+insertQuery := s.rebind("INSERT INTO schema_migrations (version) VALUES (?)")if _, err := tx.Exec(insertQuery, m.version); err != nil {return fmt.Errorf("failed to update schema_migrations version: %w", err)@@ -470,6 +481,12 @@ func (s *SQLStore) initSchemaPostgres() error {}}+ if m.dataMigrate != nil {+ if err := m.dataMigrate(context.Background(), s, tx); err != nil {+ return fmt.Errorf("migration version %d data step failed: %w", m.version, err)+ }+ }+insertQuery := s.rebind("INSERT INTO schema_migrations (version) VALUES (?)")if _, err := tx.Exec(insertQuery, m.version); err != nil {return fmt.Errorf("failed to update schema_migrations version: %w", err)@@ -502,6 +519,205 @@ func (s *SQLStore) rebind(query string) string {return result.String()}+func migrateCanonicalPeerIDs(ctx context.Context, s *SQLStore, tx *sql.Tx) error {+ if err := canonicalizeNodePeerIDs(ctx, s, tx); err != nil {+ return err+ }+ if err := canonicalizeEnrollmentRequestPeerIDs(ctx, s, tx); err != nil {+ return err+ }+ return canonicalizeRouterPeerIDs(ctx, s, tx)+}++func canonicalizeNodePeerIDs(ctx context.Context, s *SQLStore, tx *sql.Tx) error {+ type nodeRow struct {+ rawPeerID string+ canonicalPeerID string+ banned bool+ }++ rows, err := tx.QueryContext(ctx, `SELECT peer_id, banned FROM nodes`)+ if err != nil {+ return fmt.Errorf("failed to read nodes: %w", err)+ }+ var pending []nodeRow+ for rows.Next() {+ var r nodeRow+ if err := rows.Scan(&r.rawPeerID, &r.banned); err != nil {+ _ = rows.Close()+ return fmt.Errorf("failed to scan node: %w", err)+ }+ canonical, err := api.CanonicalPeerID(r.rawPeerID)+ if err != nil {+ logger.Warnw("Ignoring node with undecodable peer ID", "peer_id", r.rawPeerID)+ continue+ }+ if canonical == r.rawPeerID {+ continue+ }+ r.canonicalPeerID = canonical+ pending = append(pending, r)+ }+ if err := rows.Err(); err != nil {+ _ = rows.Close()+ return fmt.Errorf("failed to read nodes: %w", err)+ }+ if err := rows.Close(); err != nil {+ return fmt.Errorf("failed to close nodes: %w", err)+ }++ for _, r := range pending {+ var canonicalBanned bool+ err := tx.QueryRowContext(ctx, s.rebind(`SELECT banned FROM nodes WHERE peer_id = ?`), r.canonicalPeerID).Scan(&canonicalBanned)+ switch {+ case err == sql.ErrNoRows:+ if _, err := tx.ExecContext(ctx, s.rebind(`UPDATE nodes SET peer_id = ? WHERE peer_id = ?`), r.canonicalPeerID, r.rawPeerID); err != nil {+ return fmt.Errorf("failed to rename node %q: %w", r.rawPeerID, err)+ }+ case err != nil:+ return fmt.Errorf("failed to look up node %q: %w", r.canonicalPeerID, err)+ default:+ if r.banned && !canonicalBanned {+ if _, err := tx.ExecContext(ctx, s.rebind(`UPDATE nodes SET banned = ? WHERE peer_id = ?`), true, r.canonicalPeerID); err != nil {+ return fmt.Errorf("failed to carry the ban over to node %q: %w", r.canonicalPeerID, err)+ }+ }+ if _, err := tx.ExecContext(ctx, s.rebind(`DELETE FROM nodes WHERE peer_id = ?`), r.rawPeerID); err != nil {+ return fmt.Errorf("failed to drop aliased node %q: %w", r.rawPeerID, err)+ }+ }+ }+ return nil+}++func canonicalizeEnrollmentRequestPeerIDs(ctx context.Context, s *SQLStore, tx *sql.Tx) error {+ type requestRow struct {+ id string+ rawPeerID string+ canonicalPeerID string+ createdAt int64+ }++ rows, err := tx.QueryContext(ctx, `SELECT id, peer_id, created_at FROM enrollment_requests`)+ if err != nil {+ return fmt.Errorf("failed to read enrollment requests: %w", err)+ }+ var pending []requestRow+ for rows.Next() {+ var r requestRow+ if err := rows.Scan(&r.id, &r.rawPeerID, &r.createdAt); err != nil {+ _ = rows.Close()+ return fmt.Errorf("failed to scan enrollment request: %w", err)+ }+ canonical, err := api.CanonicalPeerID(r.rawPeerID)+ if err != nil {+ logger.Warnw("Ignoring enrollment request with undecodable peer ID", "peer_id", r.rawPeerID)+ continue+ }+ if canonical == r.rawPeerID {+ continue+ }+ r.canonicalPeerID = canonical+ pending = append(pending, r)+ }+ if err := rows.Err(); err != nil {+ _ = rows.Close()+ return fmt.Errorf("failed to read enrollment requests: %w", err)+ }+ if err := rows.Close(); err != nil {+ return fmt.Errorf("failed to close enrollment requests: %w", err)+ }++ for _, r := range pending {+ var canonicalID string+ var canonicalCreatedAt int64+ err := tx.QueryRowContext(ctx, s.rebind(`SELECT id, created_at FROM enrollment_requests WHERE peer_id = ?`), r.canonicalPeerID).Scan(&canonicalID, &canonicalCreatedAt)+ switch {+ case err == sql.ErrNoRows:+ if _, err := tx.ExecContext(ctx, s.rebind(`UPDATE enrollment_requests SET peer_id = ? WHERE id = ?`), r.canonicalPeerID, r.id); err != nil {+ return fmt.Errorf("failed to rename enrollment request %q: %w", r.id, err)+ }+ case err != nil:+ return fmt.Errorf("failed to look up enrollment request for %q: %w", r.canonicalPeerID, err)+ case r.createdAt > canonicalCreatedAt:+ if _, err := tx.ExecContext(ctx, s.rebind(`DELETE FROM enrollment_requests WHERE id = ?`), canonicalID); err != nil {+ return fmt.Errorf("failed to drop superseded enrollment request %q: %w", canonicalID, err)+ }+ if _, err := tx.ExecContext(ctx, s.rebind(`UPDATE enrollment_requests SET peer_id = ? WHERE id = ?`), r.canonicalPeerID, r.id); err != nil {+ return fmt.Errorf("failed to rename enrollment request %q: %w", r.id, err)+ }+ default:+ if _, err := tx.ExecContext(ctx, s.rebind(`DELETE FROM enrollment_requests WHERE id = ?`), r.id); err != nil {+ return fmt.Errorf("failed to drop aliased enrollment request %q: %w", r.id, err)+ }+ }+ }+ return nil+}++func canonicalizeRouterPeerIDs(ctx context.Context, s *SQLStore, tx *sql.Tx) error {+ type routerRow struct {+ rawPeerID string+ canonicalPeerID string+ lastRenewal int64+ }++ rows, err := tx.QueryContext(ctx, `SELECT peer_id, last_lease_renewal FROM routers`)+ if err != nil {+ return fmt.Errorf("failed to read routers: %w", err)+ }+ var pending []routerRow+ for rows.Next() {+ var r routerRow+ if err := rows.Scan(&r.rawPeerID, &r.lastRenewal); err != nil {+ _ = rows.Close()+ return fmt.Errorf("failed to scan router: %w", err)+ }+ canonical, err := api.CanonicalPeerID(r.rawPeerID)+ if err != nil {+ logger.Warnw("Ignoring router with undecodable peer ID", "peer_id", r.rawPeerID)+ continue+ }+ if canonical == r.rawPeerID {+ continue+ }+ r.canonicalPeerID = canonical+ pending = append(pending, r)+ }+ if err := rows.Err(); err != nil {+ _ = rows.Close()+ return fmt.Errorf("failed to read routers: %w", err)+ }+ if err := rows.Close(); err != nil {+ return fmt.Errorf("failed to close routers: %w", err)+ }++ for _, r := range pending {+ var canonicalRenewal int64+ err := tx.QueryRowContext(ctx, s.rebind(`SELECT last_lease_renewal FROM routers WHERE peer_id = ?`), r.canonicalPeerID).Scan(&canonicalRenewal)+ switch {+ case err == sql.ErrNoRows:+ if _, err := tx.ExecContext(ctx, s.rebind(`UPDATE routers SET peer_id = ? WHERE peer_id = ?`), r.canonicalPeerID, r.rawPeerID); err != nil {+ return fmt.Errorf("failed to rename router %q: %w", r.rawPeerID, err)+ }+ case err != nil:+ return fmt.Errorf("failed to look up router %q: %w", r.canonicalPeerID, err)+ case r.lastRenewal > canonicalRenewal:+ if _, err := tx.ExecContext(ctx, s.rebind(`DELETE FROM routers WHERE peer_id = ?`), r.canonicalPeerID); err != nil {+ return fmt.Errorf("failed to drop superseded router %q: %w", r.canonicalPeerID, err)+ }+ if _, err := tx.ExecContext(ctx, s.rebind(`UPDATE routers SET peer_id = ? WHERE peer_id = ?`), r.canonicalPeerID, r.rawPeerID); err != nil {+ return fmt.Errorf("failed to rename router %q: %w", r.rawPeerID, err)+ }+ default:+ if _, err := tx.ExecContext(ctx, s.rebind(`DELETE FROM routers WHERE peer_id = ?`), r.rawPeerID); err != nil {+ return fmt.Errorf("failed to drop aliased router %q: %w", r.rawPeerID, err)+ }+ }+ }+ return nil+}+// GetCurrentKey implements Store.func (s *SQLStore) GetCurrentKey(ctx context.Context) (ed25519.PrivateKey, ed25519.PublicKey, error) {query := s.rebind(`SELECT private_key, public_key FROM keyring WHERE expiration IS NULL ORDER BY id DESC LIMIT 1`)