Skip to content

Agent Mesh

fix peer Id aliasing bugs and normalise database records

Ibrahimfe411ce051cf
diff --git a/api/network.go b/api/network.go
index 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_signature
diff --git a/internal/controlplane/mesh.go b/internal/controlplane/mesh.go
index 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.MeshEve
event := &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.MeshEve
return 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.go
new file mode 100644
index 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.go
index 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 []string
resolvedMap := 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 []string
resolvedMap := 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 biscuit
validKeys, 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 id
b, 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 renewal
expiresAt := 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 status
var resp *api.BootstrapEnrollResponse
@@ -1315,7 +1319,7 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {
// 3. Create new enrollment request
enrollReq := &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.Requ
http.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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
new file mode 100644
index 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.go
index 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`)