Skip to content

Agent Mesh

Merge remote-tracking branch 'upstream/main' into controlplane_canonicalisation

Ibrahima40aeba30aa9
diff --cc internal/controlplane/server.go
index 94bd1e76,5f398ba9..15436a87
--- a/internal/controlplane/server.go
+++ b/internal/controlplane/server.go
@@@ -1475,10 -1471,8 +1475,15 @@@ func (s *Server) HandleEnrollStatus(w h
return
}
- canonical := canonicalPeerID(peerID)
++ pID, err := peer.Decode(peerID)
++ if err != nil {
++ http.Error(w, "Unauthorized", http.StatusUnauthorized)
++ return
++ }
++ canonical := pID.String()
+
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
@@@ -1861,10 -1854,8 +1866,15 @@@ func (s *Server) HandleAdminRevoke(w ht
return
}
- canonical := canonicalPeerID(req.PeerId)
++ pID, err := peer.Decode(req.PeerId)
++ if err != nil {
++ http.Error(w, "Invalid Peer ID", http.StatusBadRequest)
++ return
++ }
++ canonical := pID.String()
+
// 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
@@@ -2134,10 -2125,8 +2144,15 @@@ func (s *Server) HandleUserRevoke(w htt
return
}
- canonical := canonicalPeerID(peerID)
++ pID, err := peer.Decode(peerID)
++ if err != nil {
++ http.Error(w, "Invalid Peer ID", http.StatusBadRequest)
++ return
++ }
++ canonical := pID.String()
+
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
diff --cc internal/controlplane/server_test.go
index a58fdd63,a58fdd63..5d90248b
--- a/internal/controlplane/server_test.go
+++ b/internal/controlplane/server_test.go
@@@ -1866,15 -1866,15 +1866,32 @@@ func TestUserStatusAndTenancy(t *testin
t.Fatalf("SaveUser B failed: %v", errUserB)
}
++ privA, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
++ if err != nil {
++ t.Fatalf("GenerateKeyPair A failed: %v", err)
++ }
++ peerA, err := peer.IDFromPrivateKey(privA)
++ if err != nil {
++ t.Fatalf("IDFromPrivateKey A failed: %v", err)
++ }
++ privB, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
++ if err != nil {
++ t.Fatalf("GenerateKeyPair B failed: %v", err)
++ }
++ peerB, err := peer.IDFromPrivateKey(privB)
++ if err != nil {
++ t.Fatalf("IDFromPrivateKey B failed: %v", err)
++ }
++
nodeA := &storage.EnrolledNode{
-- PeerID: "peer-node-a",
++ PeerID: peerA.String(),
PublicKey: []byte("pubkey-a"),
Biscuit: []byte("dummy-biscuit-a"),
Role: "sam:role:node",
OwnerID: userA.ID,
}
nodeB := &storage.EnrolledNode{
-- PeerID: "peer-node-b",
++ PeerID: peerB.String(),
PublicKey: []byte("pubkey-b"),
Biscuit: []byte("dummy-biscuit-b"),
Role: "sam:role:node",
@@@ -1918,11 -1918,11 +1935,11 @@@
t.Fatalf("expected 1 node for User A, got: %d", len(enrolledNodes))
}
nodeMap := enrolledNodes[0].(map[string]interface{})
-- if nodeMap["PeerID"] != "peer-node-a" {
-- t.Errorf("expected node 'peer-node-a', got: %s", nodeMap["PeerID"])
++ if nodeMap["PeerID"] != peerA.String() {
++ t.Errorf("expected node %q, got: %s", peerA.String(), nodeMap["PeerID"])
}
-- reqRevoke, _ := http.NewRequest("POST", baseURL+"/user/revoke?id=peer-node-b", nil)
++ reqRevoke, _ := http.NewRequest("POST", baseURL+"/user/revoke?id="+peerB.String(), nil)
reqRevoke.Header.Set("Authorization", "Bearer "+tokenA)
respRevoke, err := client.Do(reqRevoke)
if err != nil {
@@@ -1933,7 -1933,7 +1950,7 @@@
}
_ = respRevoke.Body.Close()
-- reqRevokeSelf, _ := http.NewRequest("POST", baseURL+"/user/revoke?id=peer-node-a", nil)
++ reqRevokeSelf, _ := http.NewRequest("POST", baseURL+"/user/revoke?id="+peerA.String(), nil)
reqRevokeSelf.Header.Set("Authorization", "Bearer "+tokenA)
respRevokeSelf, err := client.Do(reqRevokeSelf)
if err != nil {
@@@ -1944,7 -1944,7 +1961,7 @@@
}
_ = respRevokeSelf.Body.Close()
-- nodeAUpdated, _ := store.GetNode(context.Background(), "peer-node-a")
++ nodeAUpdated, _ := store.GetNode(context.Background(), peerA.String())
if !nodeAUpdated.Banned {
t.Error("expected node A to be banned/revoked in DB")
}
@@@ -2386,6 -2386,6 +2403,81 @@@ func TestBanSurvivesKeypairRegeneration
}
}
++// TestUndecodablePeerIDRejectedAtBoundary pins that handlers decoding peer
++// IDs at the trust boundary answer 401/400 for garbage instead of letting
++// the raw string through to storage lookups.
++func TestUndecodablePeerIDRejectedAtBoundary(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"
++
++ user := &storage.User{
++ ID: "boundary-sub",
++ Email: "[email protected]",
++ Role: "user",
++ CreatedAt: time.Now(),
++ }
++ if err := store.SaveUser(context.Background(), user); err != nil {
++ t.Fatalf("SaveUser failed: %v", err)
++ }
++
++ client := &http.Client{Timeout: 5 * time.Second}
++
++ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
++ if err != nil {
++ t.Fatal(err)
++ }
++ ts := time.Now().UnixMilli()
++ sig, err := priv.Sign(api.EnrollStatusChallenge("not-a-peer-id", ts))
++ if err != nil {
++ t.Fatal(err)
++ }
++ statusReq, _ := http.NewRequest(http.MethodGet, baseURL+"/enroll/status?peer_id=not-a-peer-id", nil)
++ statusReq.Header.Set(api.HeaderChallengeTimestamp, strconv.FormatInt(ts, 10))
++ statusReq.Header.Set(api.HeaderChallengeSignature, base64.RawURLEncoding.EncodeToString(sig))
++ resp, err := client.Do(statusReq)
++ if err != nil {
++ t.Fatalf("GET /enroll/status failed: %v", err)
++ }
++ _ = resp.Body.Close()
++ if resp.StatusCode != http.StatusUnauthorized {
++ t.Errorf("/enroll/status with undecodable peer_id: got %d, want 401", resp.StatusCode)
++ }
++
++ revokeData, _ := proto.Marshal(&api.TokenRevokeRequest{PeerId: "not-a-peer-id"})
++ adminReq, _ := http.NewRequest(http.MethodPost, baseURL+"/admin/revoke", bytes.NewReader(revokeData))
++ adminReq.Header.Set("Authorization", "Bearer super-secret-admin-token")
++ resp, err = client.Do(adminReq)
++ if err != nil {
++ t.Fatalf("POST /admin/revoke failed: %v", err)
++ }
++ _ = resp.Body.Close()
++ if resp.StatusCode != http.StatusBadRequest {
++ t.Errorf("/admin/revoke with undecodable peer_id: got %d, want 400", resp.StatusCode)
++ }
++
++ userToken := mintToken(map[string]interface{}{
++ "iss": issuer,
++ "sub": user.ID,
++ "email": user.Email,
++ "aud": "sam-mesh-audience",
++ })
++ userReq, _ := http.NewRequest(http.MethodPost, baseURL+"/user/revoke?id=not-a-peer-id", nil)
++ userReq.Header.Set("Authorization", "Bearer "+userToken)
++ resp, err = client.Do(userReq)
++ if err != nil {
++ t.Fatalf("POST /user/revoke failed: %v", err)
++ }
++ _ = resp.Body.Close()
++ if resp.StatusCode != http.StatusBadRequest {
++ t.Errorf("/user/revoke with undecodable peer_id: got %d, want 400", resp.StatusCode)
++ }
++}
++
// TestBootstrapTokenOwnerPropagatesToNode ensures a node enrolled with a user-owned
// bootstrap token is attributed to that user, which is what makes the console's
// per-user node listing work.
diff --cc internal/storage/sql_store.go
index b2032f88,79291766..29daa0f5
--- a/internal/storage/sql_store.go
+++ b/internal/storage/sql_store.go
@@@ -519,205 -502,6 +519,196 @@@ func (s *SQLStore) rebind(query 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)
+ }
++ defer func() { _ = rows.Close() }()
++
+ 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)
+ }
++ defer func() { _ = rows.Close() }()
++
+ 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)
+ }
++ defer func() { _ = rows.Close() }()
++
+ 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`)
diff --cc tests/integration/controlplane_pubsub_integration_test.go
index 04ac9e98,04ac9e98..743eb742
--- a/tests/integration/controlplane_pubsub_integration_test.go
+++ b/tests/integration/controlplane_pubsub_integration_test.go
@@@ -28,6 -28,6 +28,7 @@@ import
"github.com/google/sam/internal/storage"
"github.com/libp2p/go-libp2p"
pubsub "github.com/libp2p/go-libp2p-pubsub"
++ "github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/peer"
"google.golang.org/protobuf/proto"
)
@@@ -175,7 -175,7 +176,15 @@@ func TestControlPlanePubSubEventIntegra
}
// 5. Enroll a dummy node in storage and trigger POST /admin/revoke (BANNED event)
-- targetPeerID := "12D3KooWTestPeerToBan12345678901234567890"
++ targetPriv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
++ if err != nil {
++ t.Fatalf("failed to generate target key: %v", err)
++ }
++ targetPeer, err := peer.IDFromPrivateKey(targetPriv)
++ if err != nil {
++ t.Fatalf("failed to derive target peer ID: %v", err)
++ }
++ targetPeerID := targetPeer.String()
nodeRecord := &storage.EnrolledNode{
PeerID: targetPeerID,
PublicKey: []byte("dummy-key"),