Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
controlplane: bans survive keypair regeneration and gate both enrollment paths
Antonio Ojeaaa84f0baeb80
diff --git a/internal/controlplane/server.go b/internal/controlplane/server.goindex 5e86afed..ead125fa 100644--- a/internal/controlplane/server.go+++ b/internal/controlplane/server.go@@ -470,6 +470,29 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {return}+ // 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)+ http.Error(w, "Internal server error", http.StatusInternalServerError)+ return+ } else if banned {+ logger.Warnw("Banned node attempted enrollment", "peer_id", req.PeerId)+ 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)+ http.Error(w, "Internal server error", http.StatusInternalServerError)+ return+ } else if banned {+ logger.Warnw("Banned identity attempted enrollment", "peer_id", req.PeerId, "identity", key)+ http.Error(w, "Identity is banned", http.StatusForbidden)+ return+ }+ }+// Mesh policy is distributed dynamically to the target nodes, no need to inject into token.// Fetch current signing private key@@ -1229,6 +1252,19 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {return}+ // 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)+ http.Error(w, "Internal server error", http.StatusInternalServerError)+ return+ } else if banned {+ logger.Warnw("Banned node attempted bootstrap enrollment", "peer_id", req.PeerId)+ s.writeEnrollError(w, api.EnrollmentStatus_ENROLLMENT_STATUS_REJECTED, "Node is banned")+ return+ }+// 2. Check for existing enrollment requestexistingReq, err := s.store.GetEnrollmentRequest(ctx, req.PeerId)if err == nil {@@ -1798,7 +1834,7 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {}// Retrieve the node from storage to verify it exists- _, err = s.store.GetNode(ctx, req.PeerId)+ node, err := s.store.GetNode(ctx, req.PeerId)if err == storage.ErrNotFound {http.Error(w, "Node not found", http.StatusNotFound)return@@ -1808,8 +1844,7 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {return}- // Set node as banned (revoked)- if err := s.store.SetNodeBanned(ctx, req.PeerId, true); err != nil {+ if err := s.banNode(ctx, node); err != nil {logger.Errorf("Failed to ban/revoke node %s: %v", req.PeerId, err)http.Error(w, "Internal server error", http.StatusInternalServerError)return@@ -2086,7 +2121,7 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {return}- if err := s.store.SetNodeBanned(ctx, peerID, true); err != nil {+ if err := s.banNode(ctx, node); err != nil {logger.Errorf("Failed to revoke node: %v", err)http.Error(w, "Internal server error", http.StatusInternalServerError)return@@ -2100,6 +2135,40 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {_, _ = w.Write([]byte("Node revoked successfully"))}+// oidcIdentityKey names an enrolled OIDC identity independently of any+// keypair: issuer and subject, the pair the issuer promises stable. Empty+// when there is no subject (e.g. bootstrap enrollments).+func oidcIdentityKey(claims jwt.MapClaims) string {+ if claims == nil {+ return ""+ }+ sub, _ := claims["sub"].(string)+ if sub == "" {+ return ""+ }+ iss, _ := claims["iss"].(string)+ return iss + "|" + sub+}++// banNode bans the device key and, when the record carries OIDC claims, the+// enrolled identity behind it, so the ban survives keypair regeneration.+func (s *Server) banNode(ctx context.Context, node *storage.EnrolledNode) error {+ if err := s.store.SetNodeBanned(ctx, node.PeerID, true); err != nil {+ return err+ }+ if node.ClaimsJSON == "" {+ return nil+ }+ var claims jwt.MapClaims+ if err := json.Unmarshal([]byte(node.ClaimsJSON), &claims); err != nil {+ return fmt.Errorf("stored claims for %s are unreadable: %w", node.PeerID, err)+ }+ if key := oidcIdentityKey(claims); key != "" {+ return s.store.SetIdentityBanned(ctx, key, true)+ }+ return nil+}+// allowedLabelPatterns collects the label grants of every role an identity// resolves to. A role that names none contributes none, so an identity with no// grant anywhere may declare no labels at all.diff --git a/internal/controlplane/server_test.go b/internal/controlplane/server_test.goindex b56293ff..9bea6ce2 100644--- a/internal/controlplane/server_test.go+++ b/internal/controlplane/server_test.go@@ -2207,6 +2207,91 @@ func TestAuthDenialPaths(t *testing.T) {})}+// TestBanSurvivesKeypairRegeneration pins the fix for the GHSA-cgmg-9xf6-rrgw+// ban-bypass claim: bans were keyed only on peer_id, which the node itself+// mints, so a banned operator regenerated a keypair and re-enrolled. Revoking+// now also bans the OIDC identity (issuer|subject) and /register checks both.+func TestBanSurvivesKeypairRegeneration(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)+ }++ enrollKey := func(t *testing.T, priv crypto.PrivKey, sub string) int {+ t.Helper()+ pID, err := peer.IDFromPrivateKey(priv)+ if err != nil {+ t.Fatal(err)+ }+ 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: pID.String(),+ 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+ }+ newKey := func(t *testing.T) crypto.PrivKey {+ t.Helper()+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)+ if err != nil {+ t.Fatal(err)+ }+ return priv+ }++ bannedKey := newKey(t)+ if status := enrollKey(t, bannedKey, "ban-me"); status != http.StatusOK {+ t.Fatalf("initial enrollment: got %d, want 200", status)+ }++ bannedPeer, _ := peer.IDFromPrivateKey(bannedKey)+ revokeData, _ := proto.Marshal(&api.TokenRevokeRequest{PeerId: bannedPeer.String()})+ req, _ := http.NewRequest("POST", 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 := enrollKey(t, bannedKey, "ban-me"); status != http.StatusForbidden {+ t.Errorf("re-enrollment with the banned keypair: got %d, want 403", status)+ }+ // Same identity behind a fresh keypair: the bypass this test exists for.+ if status := enrollKey(t, newKey(t), "ban-me"); status != http.StatusForbidden {+ t.Errorf("re-enrollment with a fresh keypair: got %d, want 403", status)+ }+ // An unrelated identity keeps working.+ if status := enrollKey(t, newKey(t), "somebody-else"); status != http.StatusOK {+ t.Errorf("unrelated identity: got %d, want 200", status)+ }+}+// 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 --git a/internal/storage/sql_store.go b/internal/storage/sql_store.goindex ed12b367..86abd092 100644--- a/internal/storage/sql_store.go+++ b/internal/storage/sql_store.go@@ -351,6 +351,24 @@ var migrations = []migration{`ALTER TABLE enrollment_requests ADD COLUMN labels_json TEXT DEFAULT '' NOT NULL`,},},+ {+ // A ban must outlive the keypair that carried it: banning a node also+ // bans the enrolled OIDC identity (issuer|subject), which a fresh+ // peer id cannot shed.+ version: 8,+ postgres: []string{+ `CREATE TABLE IF NOT EXISTS banned_identities (+ identity VARCHAR(512) PRIMARY KEY,+ banned_at BIGINT NOT NULL+ )`,+ },+ sqlite: []string{+ `CREATE TABLE IF NOT EXISTS banned_identities (+ identity TEXT PRIMARY KEY,+ banned_at BIGINT NOT NULL+ )`,+ },+ },}func (s *SQLStore) initSchema() error {@@ -693,6 +711,35 @@ func (s *SQLStore) IsNodeBanned(ctx context.Context, peerID string) (bool, errorreturn banned, nil}+// SetIdentityBanned implements Store.+func (s *SQLStore) SetIdentityBanned(ctx context.Context, identity string, banned bool) error {+ if identity == "" {+ return fmt.Errorf("identity cannot be empty")+ }+ if banned {+ query := s.rebind(`INSERT INTO banned_identities (identity, banned_at) VALUES (?, ?) ON CONFLICT (identity) DO NOTHING`)+ _, err := s.db.ExecContext(ctx, query, identity, time.Now().Unix())+ return err+ }+ query := s.rebind(`DELETE FROM banned_identities WHERE identity = ?`)+ _, err := s.db.ExecContext(ctx, query, identity)+ return err+}++// IsIdentityBanned implements Store.+func (s *SQLStore) IsIdentityBanned(ctx context.Context, identity string) (bool, error) {+ query := s.rebind(`SELECT 1 FROM banned_identities WHERE identity = ?`)+ var one int+ err := s.db.QueryRowContext(ctx, query, identity).Scan(&one)+ if err == sql.ErrNoRows {+ return false, nil+ }+ if err != nil {+ return false, err+ }+ return true, nil+}+// UpsertRouterLease implements Store.func (s *SQLStore) UpsertRouterLease(ctx context.Context, lease *RouterLease) error {addrsBytes, err := json.Marshal(lease.Addresses)diff --git a/internal/storage/sql_store_test.go b/internal/storage/sql_store_test.goindex 077a82a2..baf0f9d1 100644--- a/internal/storage/sql_store_test.go+++ b/internal/storage/sql_store_test.go@@ -326,6 +326,53 @@ func TestNodeEnrollmentOps(t *testing.T) {}}+func TestIdentityBanOps(t *testing.T) {+ store := newTestStore(t)+ defer func() { _ = store.Close() }()++ ctx := context.Background()+ identity := "http://issuer.example|banned-sub"++ banned, err := store.IsIdentityBanned(ctx, identity)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if banned {+ t.Fatalf("expected identity not banned by default")+ }++ if err := store.SetIdentityBanned(ctx, identity, true); err != nil {+ t.Fatalf("failed to ban identity: %v", err)+ }+ // Banning twice must not error: two revoked nodes can share one identity.+ if err := store.SetIdentityBanned(ctx, identity, true); err != nil {+ t.Fatalf("re-banning identity: %v", err)+ }++ banned, err = store.IsIdentityBanned(ctx, identity)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !banned {+ t.Fatalf("expected identity to be banned")+ }++ if err := store.SetIdentityBanned(ctx, identity, false); err != nil {+ t.Fatalf("failed to unban identity: %v", err)+ }+ banned, err = store.IsIdentityBanned(ctx, identity)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if banned {+ t.Fatalf("expected identity to be unbanned")+ }++ if err := store.SetIdentityBanned(ctx, "", true); err == nil {+ t.Fatalf("expected an error banning the empty identity")+ }+}+func TestRouterLeaseOps(t *testing.T) {store := newTestStore(t)defer func() { _ = store.Close() }()diff --git a/internal/storage/storage.go b/internal/storage/storage.goindex f1ee555d..bae522db 100644--- a/internal/storage/storage.go+++ b/internal/storage/storage.go@@ -169,6 +169,14 @@ type Store interface {// IsNodeBanned checks if a node is currently banned.IsNodeBanned(ctx context.Context, peerID string) (bool, error)+ // SetIdentityBanned bans or unbans an enrolled OIDC identity, keyed as+ // "issuer|subject". A node ban is keyed on a self-generated peer id, so+ // this is what makes a ban survive keypair regeneration.+ SetIdentityBanned(ctx context.Context, identity string, banned bool) error++ // IsIdentityBanned checks if an identity is currently banned.+ IsIdentityBanned(ctx context.Context, identity string) (bool, error)+// UpsertRouterLease updates or creates a lease for a sam-router.UpsertRouterLease(ctx context.Context, lease *RouterLease) error