Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
Update state_query.go (#6662)
r33drichards6d88a62fcbae
diff --git a/libs/fleet/backend/auth/authz.rego b/libs/fleet/backend/auth/authz.regoindex 2b867dec15..3cc4da2cf4 100644--- a/libs/fleet/backend/auth/authz.rego+++ b/libs/fleet/backend/auth/authz.rego@@ -389,12 +389,14 @@ valid_dns_label(s) {# Read-only state SQL. PostgreSQL RLS remains the row-visibility boundary.allow {input.route == "/api/state/query"+ input.method == "QUERY"input.user.sub != ""is_interactive_client}allow {input.route == "/api/state/query"+ input.method == "QUERY"input.user.sub != ""is_user_key_client}diff --git a/libs/fleet/backend/auth/authz_test.rego b/libs/fleet/backend/auth/authz_test.regoindex f1dc977e24..63e220a4fe 100644--- a/libs/fleet/backend/auth/authz_test.rego+++ b/libs/fleet/backend/auth/authz_test.rego@@ -935,7 +935,7 @@ test_user_api_key_no_sub_denied if {test_state_query_spa_allowed if {authz.allow with input as {"route": "/api/state/query",- "method": "POST",+ "method": "QUERY","path": "/api/state/query","params": {},"user": {"sub": "alice", "azp": "cyclops-cs-spa"},@@ -945,7 +945,7 @@ test_state_query_spa_allowed if {test_state_query_user_key_allowed if {authz.allow with input as {"route": "/api/state/query",- "method": "POST",+ "method": "QUERY","path": "/api/state/query","params": {},"user": {"sub": "alice", "azp": "ukey-alice"},@@ -955,7 +955,7 @@ test_state_query_user_key_allowed if {test_state_query_untrusted_client_denied if {not authz.allow with input as {"route": "/api/state/query",- "method": "POST",+ "method": "QUERY","path": "/api/state/query","params": {},"user": {"sub": "alice", "azp": "untrusted"},@@ -965,9 +965,19 @@ test_state_query_untrusted_client_denied if {test_state_query_empty_subject_denied if {not authz.allow with input as {"route": "/api/state/query",- "method": "POST",+ "method": "QUERY","path": "/api/state/query","params": {},"user": {"sub": "", "azp": "cyclops-cs-spa"},}}++test_state_query_post_denied if {+ not authz.allow with input as {+ "route": "/api/state/query",+ "method": "POST",+ "path": "/api/state/query",+ "params": {},+ "user": {"sub": "alice", "azp": "cyclops-cs-spa"},+ }+}diff --git a/libs/fleet/backend/config/config.go b/libs/fleet/backend/config/config.goindex 6bed6aa722..6026218046 100644--- a/libs/fleet/backend/config/config.go+++ b/libs/fleet/backend/config/config.go@@ -21,15 +21,14 @@ import ()type Configuration struct {- WebServer WebServerConfiguration- Auth AuthConfiguration- Keycloak KeycloakConfiguration- Gateway GatewayConfiguration- Database DatabaseConfiguration- StateQuery StateQueryConfiguration- Stripe StripeConfiguration- Metrics MetricsConfiguration- Telemetry TelemetryConfiguration+ WebServer WebServerConfiguration+ Auth AuthConfiguration+ Keycloak KeycloakConfiguration+ Gateway GatewayConfiguration+ Database DatabaseConfiguration+ Stripe StripeConfiguration+ Metrics MetricsConfiguration+ Telemetry TelemetryConfiguration}type WebServerConfiguration struct {@@ -93,17 +92,12 @@ type StripeConfiguration struct {// GitHub OIDC trust policies). An empty URL disables those routes (503),// keeping the backend bootable without a database — see CUA-675.type DatabaseConfiguration struct {- URL string // DATABASE_URL — migration/control and GitHub trust-policy storage- StateQueryURL string // STATE_QUERY_DATABASE_URL — restricted query broker- StateWriterURL string // STATE_WRITER_DATABASE_URL — restricted projector writer- StateExporterURL string // STATE_EXPORTER_DATABASE_URL — restricted outbox exporter- StateRoleAdminURL string // STATE_ROLE_ADMIN_DATABASE_URL — tenant-role reconciler-}--type StateQueryConfiguration struct {- MaxRows int- TimeoutMS int- MaxSQLBytes int+ URL string // DATABASE_URL — migration/control and GitHub trust-policy storage+ StateQueryDSN string // STATE_QUERY_DATABASE_DSN — tenant query connection options+ StateQueryTenantPassword string // STATE_QUERY_TENANT_PASSWORD — shared tenant query login password+ StateWriterURL string // STATE_WRITER_DATABASE_URL — restricted projector writer+ StateExporterURL string // STATE_EXPORTER_DATABASE_URL — restricted outbox exporter+ StateRoleAdminURL string // STATE_ROLE_ADMIN_DATABASE_URL — fixed-role bootstrap only}type MetricsConfiguration struct {@@ -148,13 +142,11 @@ var specs = []flagSpec{{"gateway.port", "orch-port", "ORCH_PORT", "80", "orchestrator port"},{"gateway.cluster-domain", "cluster-domain", "CLUSTER_DOMAIN", "svc.cluster.local", "in-cluster DNS domain"},{"database.url", "database-url", "DATABASE_URL", "", "Postgres URL for trust-policy storage (enables /api/github-trust-policies)"},- {"database.state-query-url", "state-query-database-url", "STATE_QUERY_DATABASE_URL", "", "Restricted Postgres URL for Kubernetes state queries"},+ {"database.state-query-dsn", "state-query-database-dsn", "STATE_QUERY_DATABASE_DSN", "", "Postgres connection options for tenant state queries"},+ {"database.state-query-tenant-password", "state-query-tenant-password", "STATE_QUERY_TENANT_PASSWORD", "", "Shared password for tenant query login roles"},{"database.state-writer-url", "state-writer-database-url", "STATE_WRITER_DATABASE_URL", "", "Restricted Postgres URL for Kubernetes state projection"},{"database.state-exporter-url", "state-exporter-database-url", "STATE_EXPORTER_DATABASE_URL", "", "Restricted Postgres URL for Kubernetes state history export"},{"database.state-role-admin-url", "state-role-admin-database-url", "STATE_ROLE_ADMIN_DATABASE_URL", "", "Restricted Postgres URL for Kubernetes tenant-role reconciliation"},- {"state-query.max-rows", "state-query-max-rows", "STATE_QUERY_MAX_ROWS", "1000", "Maximum rows returned by a state query"},- {"state-query.timeout-ms", "state-query-timeout-ms", "STATE_QUERY_TIMEOUT_MS", "5000", "State query statement timeout in milliseconds"},- {"state-query.max-sql-bytes", "state-query-max-sql-bytes", "STATE_QUERY_MAX_SQL_BYTES", "65536", "Maximum state query SQL size in bytes"},{"stripe.secret-key", "stripe-secret-key", "STRIPE_SECRET_KEY", "", "Stripe secret key (server-only)"},{"stripe.webhook-secret", "stripe-webhook-secret", "STRIPE_WEBHOOK_SECRET", "", "Stripe webhook signing secret"},{"stripe.checkout-success-url", "stripe-checkout-success-url", "STRIPE_CHECKOUT_SUCCESS_URL", "", "Stripe Checkout success redirect URL"},@@ -241,16 +233,12 @@ func LoadConfig() (*Configuration, error) {ClusterDomain: viper.GetString("gateway.cluster-domain"),},Database: DatabaseConfiguration{- URL: viper.GetString("database.url"),- StateQueryURL: viper.GetString("database.state-query-url"),- StateWriterURL: viper.GetString("database.state-writer-url"),- StateExporterURL: viper.GetString("database.state-exporter-url"),- StateRoleAdminURL: viper.GetString("database.state-role-admin-url"),- },- StateQuery: StateQueryConfiguration{- MaxRows: viper.GetInt("state-query.max-rows"),- TimeoutMS: viper.GetInt("state-query.timeout-ms"),- MaxSQLBytes: viper.GetInt("state-query.max-sql-bytes"),+ URL: viper.GetString("database.url"),+ StateQueryDSN: viper.GetString("database.state-query-dsn"),+ StateQueryTenantPassword: viper.GetString("database.state-query-tenant-password"),+ StateWriterURL: viper.GetString("database.state-writer-url"),+ StateExporterURL: viper.GetString("database.state-exporter-url"),+ StateRoleAdminURL: viper.GetString("database.state-role-admin-url"),},Stripe: StripeConfiguration{SecretKey: viper.GetString("stripe.secret-key"),diff --git a/libs/fleet/backend/config/config_test.go b/libs/fleet/backend/config/config_test.goindex 07baef0a38..e4693c750a 100644--- a/libs/fleet/backend/config/config_test.go+++ b/libs/fleet/backend/config/config_test.go@@ -166,7 +166,8 @@ func TestLoadConfig_StateDatabaseURLs(t *testing.T) {t.Cleanup(viper.Reset)t.Setenv("KC_ADMIN_CLIENT_SECRET", "secret")t.Setenv("DATABASE_URL", "postgres://admin@db/cyclops")- t.Setenv("STATE_QUERY_DATABASE_URL", "postgres://k8s_query_broker@db/cyclops")+ t.Setenv("STATE_QUERY_DATABASE_DSN", "postgres://db/cyclops?sslmode=require")+ t.Setenv("STATE_QUERY_TENANT_PASSWORD", "tenant-password")t.Setenv("STATE_WRITER_DATABASE_URL", "postgres://k8s_state_writer@db/cyclops")t.Setenv("STATE_EXPORTER_DATABASE_URL", "postgres://k8s_state_exporter@db/cyclops")t.Setenv("STATE_ROLE_ADMIN_DATABASE_URL", "postgres://k8s_role_admin@db/cyclops")@@ -176,8 +177,11 @@ func TestLoadConfig_StateDatabaseURLs(t *testing.T) {if err != nil {t.Fatalf("LoadConfig() error = %v", err)}- if got, want := cfg.Database.StateQueryURL, "postgres://k8s_query_broker@db/cyclops"; got != want {- t.Fatalf("Database.StateQueryURL = %q, want %q", got, want)+ if got, want := cfg.Database.StateQueryDSN, "postgres://db/cyclops?sslmode=require"; got != want {+ t.Fatalf("Database.StateQueryDSN = %q, want %q", got, want)+ }+ if got, want := cfg.Database.StateQueryTenantPassword, "tenant-password"; got != want {+ t.Fatalf("Database.StateQueryTenantPassword = %q, want %q", got, want)}if got, want := cfg.Database.StateWriterURL, "postgres://k8s_state_writer@db/cyclops"; got != want {t.Fatalf("Database.StateWriterURL = %q, want %q", got, want)@@ -186,24 +190,6 @@ func TestLoadConfig_StateDatabaseURLs(t *testing.T) {t.Fatalf("Database.StateExporterURL = %q, want %q", got, want)}if got, want := cfg.Database.StateRoleAdminURL, "postgres://k8s_role_admin@db/cyclops"; got != want {- t.Fatalf("Database.StateRoleAdminURL = %q, want %q", got, want)- }-}--func TestLoadConfig_StateQueryLimits(t *testing.T) {- viper.Reset()- t.Cleanup(viper.Reset)- t.Setenv("KC_ADMIN_CLIENT_SECRET", "secret")- t.Setenv("STATE_QUERY_MAX_ROWS", "250")- t.Setenv("STATE_QUERY_TIMEOUT_MS", "3000")- t.Setenv("STATE_QUERY_MAX_SQL_BYTES", "8192")- RegisterFlags(pflag.NewFlagSet("state-query-limits-test", pflag.ContinueOnError))-- cfg, err := LoadConfig()- if err != nil {- t.Fatal(err)- }- if cfg.StateQuery.MaxRows != 250 || cfg.StateQuery.TimeoutMS != 3000 || cfg.StateQuery.MaxSQLBytes != 8192 {- t.Fatalf("StateQuery = %#v", cfg.StateQuery)+ t.Fatalf("Database.StateRoleAdminURL (fixed-role bootstrap only) = %q, want %q", got, want)}}diff --git a/libs/fleet/backend/go.mod b/libs/fleet/backend/go.modindex d3c3996ee5..ddb78ecb7c 100644--- a/libs/fleet/backend/go.mod+++ b/libs/fleet/backend/go.mod@@ -12,7 +12,6 @@ require (github.com/jackc/pgx/v5 v5.5.5github.com/open-feature/go-sdk v1.17.0github.com/open-policy-agent/opa v0.69.0- github.com/pganalyze/pg_query_go/v6 v6.2.2github.com/prometheus/client_golang v1.20.4github.com/spf13/cobra v1.10.2github.com/spf13/pflag v1.0.10@@ -115,7 +114,7 @@ require (golang.org/x/net v0.44.0 // indirectgolang.org/x/sys v0.36.0 // indirectgolang.org/x/tools v0.37.0 // indirect- google.golang.org/protobuf v1.34.2+ google.golang.org/protobuf v1.34.2 // indirectgopkg.in/yaml.v2 v2.4.0 // indirectsigs.k8s.io/yaml v1.4.0 // indirect)diff --git a/libs/fleet/backend/go.sum b/libs/fleet/backend/go.sumindex 54c035030e..d8fa818391 100644--- a/libs/fleet/backend/go.sum+++ b/libs/fleet/backend/go.sum@@ -167,8 +167,6 @@ github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=-github.com/pganalyze/pg_query_go/v6 v6.2.2 h1:O0L6zMC226R82RF3X5n0Ki6HjytDsoAzuzp4ATVAHNo=-github.com/pganalyze/pg_query_go/v6 v6.2.2/go.mod h1:Cn6+j4870kJz3iYNsb0VsNG04vpSWgEvBwc590J4qD0=github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=diff --git a/libs/fleet/backend/handlers/handlers.go b/libs/fleet/backend/handlers/handlers.goindex 00b3a8a037..a0fdbaa133 100644--- a/libs/fleet/backend/handlers/handlers.go+++ b/libs/fleet/backend/handlers/handlers.go@@ -4,7 +4,6 @@ package handlersimport ("bufio"- "context""encoding/json""fmt""net"@@ -25,14 +24,12 @@ type Handlers struct {AuthCfg config.AuthConfigurationKC config.KeycloakConfigurationStripe config.StripeConfiguration- StateQuery config.StateQueryConfigurationBilling BillingServiceWebhookVerifier WebhookVerifierGitHubTrustPolicies githubtrust.Store- StateQueryExecutor StateQueryExecutor- StateQueryAuthorize func(context.Context, *auth.User) (bool, error)+ StateQueryExecutor StateQueryExecutor// WorkloadAdmin manages per-tenant clients in the workloads realm so// OSGym pool VMs can obtain a tenant-scoped OIDC token. nil disables@@ -51,7 +48,6 @@ func New(admin *keycloak.Admin, cfg *config.Configuration) Handlers {AuthCfg: cfg.Auth,KC: cfg.Keycloak,Stripe: cfg.Stripe,- StateQuery: cfg.StateQuery,}}diff --git a/libs/fleet/backend/handlers/state_query.go b/libs/fleet/backend/handlers/state_query.goindex 3e6aa344c8..efe3280ca8 100644--- a/libs/fleet/backend/handlers/state_query.go+++ b/libs/fleet/backend/handlers/state_query.go@@ -3,75 +3,113 @@ package handlersimport ("context""encoding/json"- "errors"+ "io"+ "log/slog"+ "mime""net/http"- "cyclops-cs-backend/auth""cyclops-cs-backend/identity""cyclops-cs-backend/statequery"+ "github.com/jackc/pgx/v5/pgconn")+const stateQueryBodyMaxBytes = 1 << 20+type StateQueryExecutor interface {- Execute(context.Context, string, bool, statequery.ValidatedQuery) (statequery.ResultSet, error)+ Execute(context.Context, string, string, statequery.ResultWriter) error}-type stateQueryRequest struct {- SQL string `json:"sql"`+type stateQueryStreamWriter struct {+ response http.ResponseWriter+ encoder *json.Encoder+ controller *http.ResponseController+ started bool}-func (h Handlers) QueryState(w http.ResponseWriter, r *http.Request) {- if h.StateQueryExecutor == nil {- writeErr(w, http.StatusServiceUnavailable, "state query unavailable")- return- }- user := currentUser(r)- if user == nil || user.ID == "" {- writeErr(w, http.StatusUnauthorized, "missing user")- return+type stateQueryFieldsEvent struct {+ Type string `json:"type"`+ Fields []pgconn.FieldDescription `json:"fields"`+}++type stateQueryRowEvent struct {+ Type string `json:"type"`+ Values []any `json:"values"`+}++type stateQueryDoneEvent struct {+ Type string `json:"type"`+}++type stateQueryErrorEvent struct {+ Type string `json:"type"`+ Error string `json:"error"`+}++func newStateQueryStreamWriter(response http.ResponseWriter) *stateQueryStreamWriter {+ return &stateQueryStreamWriter{+ response: response,+ encoder: json.NewEncoder(response),+ controller: http.NewResponseController(response),}+}- limits := statequery.DefaultLimits()- if h.StateQuery.MaxRows > 0 {- limits.MaxRows = h.StateQuery.MaxRows+func (writer *stateQueryStreamWriter) WriteFieldDescriptions(fields []pgconn.FieldDescription) error {+ return writer.write(stateQueryFieldsEvent{Type: "fields", Fields: fields})+}++func (writer *stateQueryStreamWriter) WriteRow(values []any) error {+ return writer.write(stateQueryRowEvent{Type: "row", Values: values})+}++func (writer *stateQueryStreamWriter) Finish(err error) error {+ if err != nil {+ return writer.write(stateQueryErrorEvent{Type: "error", Error: err.Error()})}- if h.StateQuery.TimeoutMS > 0 {- limits.TimeoutMS = h.StateQuery.TimeoutMS+ return writer.write(stateQueryDoneEvent{Type: "done"})+}++func (writer *stateQueryStreamWriter) write(event any) error {+ if !writer.started {+ writer.response.Header().Set("Content-Type", "application/x-ndjson")+ writer.response.WriteHeader(http.StatusOK)+ writer.started = true}- if h.StateQuery.MaxSQLBytes > 0 {- limits.MaxSQLBytes = h.StateQuery.MaxSQLBytes+ if err := writer.encoder.Encode(event); err != nil {+ return err}- decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, int64(limits.MaxSQLBytes+1024)))- decoder.DisallowUnknownFields()- var request stateQueryRequest- if err := decoder.Decode(&request); err != nil {- writeErr(w, http.StatusBadRequest, "invalid request")+ return writer.controller.Flush()+}++func (h Handlers) QueryState(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Accept-Query", "application/sql")+ w.Header().Set("Cache-Control", "private, no-store")+ if h.StateQueryExecutor == nil {+ writeErr(w, http.StatusServiceUnavailable, "state query unavailable")return}- validated, err := statequery.Validate(request.SQL, limits)+ mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))if err != nil {- writeErr(w, http.StatusBadRequest, "invalid state query")+ w.Header().Set("Accept", "application/sql")+ writeErr(w, http.StatusUnsupportedMediaType, err.Error())return}-- authorize := h.StateQueryAuthorize- if authorize == nil {- authorize = auth.EvalIsAdmin+ if mediaType != "application/sql" {+ w.Header().Set("Accept", "application/sql")+ writeErr(w, http.StatusUnsupportedMediaType, "state query requires application/sql")+ return}- admin, err := authorize(r.Context(), user)+ body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, stateQueryBodyMaxBytes))if err != nil {- writeErr(w, http.StatusForbidden, "state query denied")+ writeErr(w, http.StatusBadRequest, err.Error())return}- result, err := h.StateQueryExecutor.Execute(- r.Context(), identity.PersonalGroup(r.Context(), user.ID), admin, validated,- )++ user := currentUser(r)+ stream := newStateQueryStreamWriter(w)+ err = stream.Finish(h.StateQueryExecutor.Execute(+ r.Context(), identity.PersonalGroup(r.Context(), user.ID), string(body), stream,+ ))if err != nil {- if errors.Is(r.Context().Err(), context.DeadlineExceeded) {- writeErr(w, http.StatusGatewayTimeout, "state query timed out")- return- }- writeErr(w, http.StatusServiceUnavailable, "state query failed")- return+ slog.Debug("state query stream failed", "err", err)}- writeJSON(w, http.StatusOK, result)}diff --git a/libs/fleet/backend/handlers/state_query_test.go b/libs/fleet/backend/handlers/state_query_test.goindex 70fb57ddc5..fbcd18f13d 100644--- a/libs/fleet/backend/handlers/state_query_test.go+++ b/libs/fleet/backend/handlers/state_query_test.go@@ -10,69 +10,103 @@ import ("cyclops-cs-backend/auth""cyclops-cs-backend/statequery"+ "github.com/jackc/pgx/v5/pgconn")type fakeStateQueryExecutor struct {tenant string- admin bool- query statequery.ValidatedQuery- result statequery.ResultSet+ query string+ fields []pgconn.FieldDescription+ rows [][]anyerr error}-func (fake *fakeStateQueryExecutor) Execute(_ context.Context, tenant string, admin bool, query statequery.ValidatedQuery) (statequery.ResultSet, error) {- fake.tenant, fake.admin, fake.query = tenant, admin, query- return fake.result, fake.err+func (fake *fakeStateQueryExecutor) Execute(_ context.Context, tenant, query string, writer statequery.ResultWriter) error {+ fake.tenant, fake.query = tenant, query+ if err := writer.WriteFieldDescriptions(fake.fields); err != nil {+ return err+ }+ for _, row := range fake.rows {+ if err := writer.WriteRow(row); err != nil {+ return err+ }+ }+ return fake.err}func TestQueryStateReturnsUnavailableWithoutExecutor(t *testing.T) {h := Handlers{}- request := withUser(httptest.NewRequest(http.MethodPost, "/api/state/query", strings.NewReader(`{"sql":"select 1"}`)), &auth.User{ID: "alice"})+ request := withUser(httptest.NewRequest("QUERY", "/api/state/query", strings.NewReader("select 1")), &auth.User{ID: "alice"})+ request.Header.Set("Content-Type", "application/sql")response := httptest.NewRecorder()h.QueryState(response, request)if response.Code != http.StatusServiceUnavailable {t.Fatalf("status = %d, body = %s", response.Code, response.Body.String())}+ if got := response.Header().Get("Accept-Query"); got != "application/sql" {+ t.Fatalf("Accept-Query = %q", got)+ }}-func TestQueryStateRejectsUnsafeSQL(t *testing.T) {- executor := &fakeStateQueryExecutor{}+func TestQueryStateStreamsRawQueryResults(t *testing.T) {+ executor := &fakeStateQueryExecutor{+ fields: []pgconn.FieldDescription{{Name: "name", DataTypeOID: 25}},+ rows: [][]any{{"alice-ns"}, {"alice-pod"}},+ }h := Handlers{StateQueryExecutor: executor}- request := withUser(httptest.NewRequest(http.MethodPost, "/api/state/query", strings.NewReader(`{"sql":"select pg_sleep(60)"}`)), &auth.User{ID: "alice"})+ query := "select pg_sleep(60)"+ request := withUser(httptest.NewRequest("QUERY", "/api/state/query", strings.NewReader(query)), &auth.User{ID: "alice"})+ request.Header.Set("Content-Type", "application/sql; charset=utf-8")response := httptest.NewRecorder()h.QueryState(response, request)- if response.Code != http.StatusBadRequest {+ if response.Code != http.StatusOK {t.Fatalf("status = %d, body = %s", response.Code, response.Body.String())}+ if executor.tenant != "user-alice" || executor.query != query {+ t.Fatalf("tenant/query = %q/%q", executor.tenant, executor.query)+ }+ if got := response.Header().Get("Content-Type"); got != "application/x-ndjson" {+ t.Fatalf("Content-Type = %q", got)+ }+ want := "" ++ `{"type":"fields","fields":[{"Name":"name","TableOID":0,"TableAttributeNumber":0,"DataTypeOID":25,"DataTypeSize":0,"TypeModifier":0,"Format":0}]}` + "\n" ++ `{"type":"row","values":["alice-ns"]}` + "\n" ++ `{"type":"row","values":["alice-pod"]}` + "\n" ++ `{"type":"done"}` + "\n"+ if response.Body.String() != want {+ t.Fatalf("body = %q, want %q", response.Body.String(), want)+ }+ if !response.Flushed {+ t.Fatal("stream was not flushed")+ }}-func TestQueryStateUsesAuthenticatedCapsuleTenant(t *testing.T) {- executor := &fakeStateQueryExecutor{result: statequery.ResultSet{Rows: [][]any{{"alice-ns"}}}}- h := Handlers{- StateQueryExecutor: executor,- StateQueryAuthorize: func(context.Context, *auth.User) (bool, error) { return false, nil },- }- request := withUser(httptest.NewRequest(http.MethodPost, "/api/state/query", strings.NewReader(`{"sql":"select name from k8s_api.current_resources"}`)), &auth.User{ID: "alice"})+func TestQueryStateRequiresSQLContentType(t *testing.T) {+ h := Handlers{StateQueryExecutor: &fakeStateQueryExecutor{}}+ request := withUser(httptest.NewRequest("QUERY", "/api/state/query", strings.NewReader("select 1")), &auth.User{ID: "alice"})response := httptest.NewRecorder()h.QueryState(response, request)- if response.Code != http.StatusOK {+ if response.Code != http.StatusUnsupportedMediaType {t.Fatalf("status = %d, body = %s", response.Code, response.Body.String())}- if executor.tenant != "user-alice" || executor.admin {- t.Fatalf("tenant/admin = %q/%t", executor.tenant, executor.admin)- }}-func TestQueryStateFailsClosedOnAuthorizationError(t *testing.T) {- executor := &fakeStateQueryExecutor{}- h := Handlers{- StateQueryExecutor: executor,- StateQueryAuthorize: func(context.Context, *auth.User) (bool, error) { return false, errors.New("opa unavailable") },+func TestQueryStateWritesExecutorErrorAsTerminalEvent(t *testing.T) {+ executor := &fakeStateQueryExecutor{+ fields: []pgconn.FieldDescription{{Name: "name", DataTypeOID: 25}},+ rows: [][]any{{"alice-ns"}},+ err: errors.New("stream failed"),}- request := withUser(httptest.NewRequest(http.MethodPost, "/api/state/query", strings.NewReader(`{"sql":"select name from k8s_api.current_resources"}`)), &auth.User{ID: "alice"})+ h := Handlers{StateQueryExecutor: executor}+ request := withUser(httptest.NewRequest("QUERY", "/api/state/query", strings.NewReader("select 1")), &auth.User{ID: "alice"})+ request.Header.Set("Content-Type", "application/sql")response := httptest.NewRecorder()h.QueryState(response, request)- if response.Code != http.StatusForbidden {+ if response.Code != http.StatusOK {t.Fatalf("status = %d, body = %s", response.Code, response.Body.String())}+ wantSuffix := `{"type":"error","error":"stream failed"}` + "\n"+ if !strings.HasSuffix(response.Body.String(), wantSuffix) {+ t.Fatalf("body = %q, want suffix %q", response.Body.String(), wantSuffix)+ }}diff --git a/libs/fleet/backend/main.go b/libs/fleet/backend/main.goindex ba52fb393f..688c640510 100644--- a/libs/fleet/backend/main.go+++ b/libs/fleet/backend/main.go@@ -100,7 +100,7 @@ func setupRouter(c handlers.Handlers) http.Handler {r.Handle("GET /api/config",withMiddlewares("/api/config", nil, c.GetConfig))- r.Handle("POST /api/state/query",+ r.Handle("QUERY /api/state/query",withMiddlewares("/api/state/query", nil, c.QueryState))// Stripe-hosted billing. Browser routes require the normal SPA JWT; the@@ -324,10 +324,9 @@ func run() error {stateRoleURLs := statequery.FixedRoleURLs{Writer: cfg.Database.StateWriterURL,Exporter: cfg.Database.StateExporterURL,- Query: cfg.Database.StateQueryURL,RoleAdmin: cfg.Database.StateRoleAdminURL,}- if stateRoleURLs.Writer != "" || stateRoleURLs.Exporter != "" || stateRoleURLs.Query != "" || stateRoleURLs.RoleAdmin != "" {+ if stateRoleURLs.Writer != "" || stateRoleURLs.Exporter != "" || stateRoleURLs.RoleAdmin != "" {if err := statequery.ReconcileFixedRoles(ctx, cfg.Database.URL, stateRoleURLs); err != nil {slog.Error("kubernetes state query: fixed-role reconciliation failed", "err", err)} else if err := statequery.Migrate(ctx, cfg.Database.URL); err != nil {@@ -337,14 +336,16 @@ func run() error {stateSchemaReady = true}} else {- slog.Info("kubernetes state query: disabled (restricted database URLs unset)")+ slog.Info("kubernetes state query: disabled (fixed-role database URLs unset)")}if stateSchemaReady {- executor, err := statequery.NewExecutor(ctx, cfg.Database.StateQueryURL, cfg.Database.StateRoleAdminURL)+ executor, err := statequery.NewExecutor(+ cfg.Database.StateQueryDSN,+ cfg.Database.StateQueryTenantPassword,+ )if err != nil {slog.Error("kubernetes state query: executor init failed; /api/state/query will return 503", "err", err)} else {- defer executor.Close()h.StateQueryExecutor = executorslog.Info("kubernetes state query: query endpoint enabled")}diff --git a/libs/fleet/backend/main_test.go b/libs/fleet/backend/main_test.goindex a3d037692b..fa63601d15 100644--- a/libs/fleet/backend/main_test.go+++ b/libs/fleet/backend/main_test.go@@ -358,3 +358,24 @@ func TestBillingSummaryGeneratedContract(t *testing.T) {t.Fatal("billing summary card must be explicitly nullable")}}++func TestStateQueryRouterUsesQueryMethod(t *testing.T) {+ router := setupRouter(handlers.Handlers{})++ queryRequest := authorizedRequest(t, "QUERY", "/api/state/query", strings.NewReader("select 1"))+ queryRequest.Header.Set("Content-Type", "application/sql")+ queryResponse := httptest.NewRecorder()+ router.ServeHTTP(queryResponse, queryRequest)+ if queryResponse.Code != http.StatusServiceUnavailable {+ t.Fatalf("QUERY status = %d, want 503; body = %s", queryResponse.Code, queryResponse.Body.String())+ }++ postResponse := httptest.NewRecorder()+ router.ServeHTTP(postResponse, authorizedRequest(t, http.MethodPost, "/api/state/query", strings.NewReader(`{"sql":"select 1"}`)))+ if postResponse.Code != http.StatusMethodNotAllowed {+ t.Fatalf("POST status = %d, want 405; body = %s", postResponse.Code, postResponse.Body.String())+ }+ if got := postResponse.Header().Get("Allow"); got != "QUERY" {+ t.Fatalf("Allow = %q, want QUERY", got)+ }+}diff --git a/libs/fleet/backend/statequery/e2e_pg_test.go b/libs/fleet/backend/statequery/e2e_pg_test.goindex 8e7bbfbb5a..d3f4fc38cd 100644--- a/libs/fleet/backend/statequery/e2e_pg_test.go+++ b/libs/fleet/backend/statequery/e2e_pg_test.go@@ -7,38 +7,35 @@ import ()func TestE2EListsProjectedNamespacesForTenant(t *testing.T) {- queryURL := os.Getenv("CYCLOPS_E2E_STATE_QUERY_URL")- roleAdminURL := os.Getenv("CYCLOPS_E2E_STATE_ROLE_ADMIN_URL")+ queryDSN := os.Getenv("CYCLOPS_E2E_STATE_QUERY_DSN")+ tenantPassword := os.Getenv("CYCLOPS_E2E_STATE_QUERY_TENANT_PASSWORD")tenant := os.Getenv("CYCLOPS_E2E_CAPSULE_TENANT")clusterID := os.Getenv("CYCLOPS_E2E_CLUSTER_ID")- if queryURL == "" || roleAdminURL == "" || tenant == "" || clusterID == "" {- t.Skip("set CYCLOPS_E2E_STATE_QUERY_URL, CYCLOPS_E2E_STATE_ROLE_ADMIN_URL, CYCLOPS_E2E_CAPSULE_TENANT, and CYCLOPS_E2E_CLUSTER_ID")+ if queryDSN == "" || tenantPassword == "" || tenant == "" || clusterID == "" {+ t.Skip("set CYCLOPS_E2E_STATE_QUERY_DSN, CYCLOPS_E2E_STATE_QUERY_TENANT_PASSWORD, CYCLOPS_E2E_CAPSULE_TENANT, and CYCLOPS_E2E_CLUSTER_ID")}ctx := context.Background()- executor, err := NewExecutor(ctx, queryURL, roleAdminURL)+ executor, err := NewExecutor(queryDSN, tenantPassword)if err != nil {t.Fatal(err)}- defer executor.Close()- query, err := Validate(`+ query := `select name, object->'metadata'->'labels'->>'capsule.clastix.io/tenant' as ownerfrom k8s_api.current_resources- where cluster_id = '`+clusterID+`'+ where cluster_id = '` + clusterID + `'and api_group = ''and resource = 'namespaces'- order by name`, DefaultLimits())+ order by name`+ writer := &collectingResultWriter{}+ err = executor.Execute(ctx, tenant, query, writer)if err != nil {t.Fatal(err)}- result, err := executor.Execute(ctx, tenant, false, query)- if err != nil {- t.Fatal(err)- }- if len(result.Rows) == 0 {+ if len(writer.rows) == 0 {t.Fatal("tenant query returned no projected namespaces")}- for _, row := range result.Rows {+ for _, row := range writer.rows {if len(row) != 2 || row[1] != tenant {t.Fatalf("row escaped tenant RLS: %#v, want tenant %q", row, tenant)}diff --git a/libs/fleet/backend/statequery/executor.go b/libs/fleet/backend/statequery/executor.goindex a0c349926c..a4ac7462f9 100644--- a/libs/fleet/backend/statequery/executor.go+++ b/libs/fleet/backend/statequery/executor.go@@ -6,30 +6,21 @@ import ("encoding/hex""errors""fmt"- "time""github.com/jackc/pgx/v5"- "github.com/jackc/pgx/v5/pgxpool"+ "github.com/jackc/pgx/v5/pgconn")var ErrExecution = errors.New("state query execution failed")-type Column struct {- Name string `json:"name"`- Type string `json:"type"`-}--type ResultSet struct {- Columns []Column `json:"columns"`- Rows [][]any `json:"rows"`- Truncated bool `json:"truncated"`- DurationMS int64 `json:"duration_ms"`- Checkpoints []any `json:"checkpoints"`+type ResultWriter interface {+ WriteFieldDescriptions([]pgconn.FieldDescription) error+ WriteRow([]any) error}type Executor struct {- queryPool *pgxpool.Pool- roleAdminPool *pgxpool.Pool+ baseConfig *pgx.ConnConfig+ tenantPassword string}func TenantRoleName(tenant string) string {@@ -37,149 +28,57 @@ func TenantRoleName(tenant string) string {return "k8s_tenant_" + hex.EncodeToString(digest[:16])}-func NewExecutor(ctx context.Context, queryURL, roleAdminURL string) (*Executor, error) {- if queryURL == "" || roleAdminURL == "" {- return nil, fmt.Errorf("state query database URLs are required")+func NewExecutor(queryDSN, tenantPassword string) (*Executor, error) {+ if queryDSN == "" || tenantPassword == "" {+ return nil, fmt.Errorf("state query DSN and tenant password are required")}- queryPool, err := pgxpool.New(ctx, queryURL)+ config, err := pgx.ParseConfig(queryDSN)if err != nil {- return nil, fmt.Errorf("open state query pool: %w", err)- }- roleAdminPool, err := pgxpool.New(ctx, roleAdminURL)- if err != nil {- queryPool.Close()- return nil, fmt.Errorf("open state role-admin pool: %w", err)- }- if err := queryPool.Ping(ctx); err != nil {- queryPool.Close()- roleAdminPool.Close()- return nil, fmt.Errorf("ping state query pool: %w", err)+ return nil, fmt.Errorf("parse state query DSN: %w", err)}- if err := roleAdminPool.Ping(ctx); err != nil {- queryPool.Close()- roleAdminPool.Close()- return nil, fmt.Errorf("ping state role-admin pool: %w", err)- }- return &Executor{queryPool: queryPool, roleAdminPool: roleAdminPool}, nil+ return &Executor{baseConfig: config, tenantPassword: tenantPassword}, nil}-func (e *Executor) Close() {- e.queryPool.Close()- e.roleAdminPool.Close()+func (e *Executor) connectionConfig(tenant string) *pgx.ConnConfig {+ config := e.baseConfig.Copy()+ config.User = TenantRoleName(tenant)+ config.Password = e.tenantPassword+ return config}-func (e *Executor) Execute(ctx context.Context, tenant string, admin bool, query ValidatedQuery) (ResultSet, error) {- role := "k8s_query_admin"- if !admin {- if tenant == "" {- return ResultSet{}, fmt.Errorf("%w: provision tenant role", ErrExecution)- }- role = TenantRoleName(tenant)- if err := e.ensureTenantRole(ctx, role, tenant); err != nil {- return ResultSet{}, fmt.Errorf("%w: provision tenant role", ErrExecution)- }+func (e *Executor) Execute(ctx context.Context, tenant, sql string, writer ResultWriter) error {+ if tenant == "" {+ return fmt.Errorf("%w: tenant is required", ErrExecution)+ }+ conn, err := pgx.ConnectConfig(ctx, e.connectionConfig(tenant))+ if err != nil {+ return fmt.Errorf("%w: connect tenant role: %v", ErrExecution, err)}+ defer conn.Close(ctx)- started := time.Now()- tx, err := e.queryPool.BeginTx(ctx, pgx.TxOptions{AccessMode: pgx.ReadOnly})+ tx, err := conn.BeginTx(ctx, pgx.TxOptions{AccessMode: pgx.ReadOnly})if err != nil {- return ResultSet{}, fmt.Errorf("%w: begin transaction", ErrExecution)+ return fmt.Errorf("%w: begin transaction", ErrExecution)}defer tx.Rollback(ctx)- if _, err := tx.Exec(ctx, "set local role "+pgx.Identifier{role}.Sanitize()); err != nil {- return ResultSet{}, fmt.Errorf("%w: assume query role", ErrExecution)- }- for setting, value := range map[string]string{- "statement_timeout": fmt.Sprintf("%dms", query.TimeoutMS),- "lock_timeout": "500ms",- "idle_in_transaction_session_timeout": "10s",- "work_mem": "16MB",- } {- if _, err := tx.Exec(ctx, `select set_config($1, $2, true)`, setting, value); err != nil {- return ResultSet{}, fmt.Errorf("%w: apply query limits", ErrExecution)- }- }- rows, err := tx.Query(ctx, query.SQL)+ rows, err := tx.Query(ctx, sql)if err != nil {- return ResultSet{}, fmt.Errorf("%w: execute select", ErrExecution)+ return fmt.Errorf("%w: execute query", ErrExecution)}defer rows.Close()- fields := rows.FieldDescriptions()- result := ResultSet{- Columns: make([]Column, len(fields)),- Rows: make([][]any, 0, query.MaxRows),- Checkpoints: []any{},- }- for index, field := range fields {- result.Columns[index] = Column{Name: field.Name, Type: postgresTypeName(field.DataTypeOID)}+ if err := writer.WriteFieldDescriptions(rows.FieldDescriptions()); err != nil {+ return err}for rows.Next() {values, err := rows.Values()if err != nil {- return ResultSet{}, fmt.Errorf("%w: decode result row", ErrExecution)+ return fmt.Errorf("%w: decode result row", ErrExecution)}- if len(result.Rows) == query.MaxRows {- result.Truncated = true- break- }- result.Rows = append(result.Rows, values)- }- if rows.Err() != nil {- return ResultSet{}, fmt.Errorf("%w: stream result rows", ErrExecution)- }- result.DurationMS = time.Since(started).Milliseconds()- return result, nil-}--func (e *Executor) ensureTenantRole(ctx context.Context, role, tenant string) error {- tx, err := e.roleAdminPool.Begin(ctx)- if err != nil {- return err- }- defer tx.Rollback(ctx)- if _, err := tx.Exec(ctx, `select pg_advisory_xact_lock(hashtext($1))`, "cyclops-state-role:"+role); err != nil {- return err- }- var exists bool- if err := tx.QueryRow(ctx, `select exists(select 1 from pg_roles where rolname = $1)`, role).Scan(&exists); err != nil {- return err- }- identifier := pgx.Identifier{role}.Sanitize()- if !exists {- if _, err := tx.Exec(ctx, "create role "+identifier+" nologin inherit nocreaterole"); err != nil {+ if err := writer.WriteRow(values); err != nil {return err}}- if _, err := tx.Exec(ctx, "grant k8s_query_tenant to "+identifier); err != nil {- return err- }- if _, err := tx.Exec(ctx, "grant "+identifier+" to k8s_query_broker"); err != nil {- return err- }- if _, err := tx.Exec(ctx, `select k8s_state.register_tenant_role($1, $2)`, role, tenant); err != nil {- return err- }- return tx.Commit(ctx)-}--func postgresTypeName(oid uint32) string {- switch oid {- case 16:- return "bool"- case 20:- return "int8"- case 23:- return "int4"- case 25:- return "text"- case 114:- return "json"- case 1184:- return "timestamptz"- case 3802:- return "jsonb"- default:- return fmt.Sprintf("oid:%d", oid)- }+ rows.Close()+ return rows.Err()}diff --git a/libs/fleet/backend/statequery/executor_test.go b/libs/fleet/backend/statequery/executor_test.goindex e7487980be..4d1e7c0530 100644--- a/libs/fleet/backend/statequery/executor_test.go+++ b/libs/fleet/backend/statequery/executor_test.go@@ -5,9 +5,26 @@ import ("os""testing"+ "github.com/jackc/pgx/v5"+ "github.com/jackc/pgx/v5/pgconn""github.com/jackc/pgx/v5/pgxpool")+type collectingResultWriter struct {+ fields []pgconn.FieldDescription+ rows [][]any+}++func (writer *collectingResultWriter) WriteFieldDescriptions(fields []pgconn.FieldDescription) error {+ writer.fields = fields+ return nil+}++func (writer *collectingResultWriter) WriteRow(row []any) error {+ writer.rows = append(writer.rows, row)+ return nil+}+func TestTenantRoleNameIsStableAndOpaque(t *testing.T) {got := TenantRoleName("user-alice")if got != "k8s_tenant_0e7b8c3e3b7f94ed81538a568a6408c6" {@@ -18,6 +35,32 @@ func TestTenantRoleNameIsStableAndOpaque(t *testing.T) {}}+func TestExecutorBuildsDirectTenantConnectionConfig(t *testing.T) {+ executor, err := NewExecutor(+ "postgres://db.example/cyclops?sslmode=require",+ "tenant-password",+ )+ if err != nil {+ t.Fatal(err)+ }+ config := executor.connectionConfig("user-alice")+ if config.User != TenantRoleName("user-alice") {+ t.Fatalf("User = %q", config.User)+ }+ if config.Password != "tenant-password" {+ t.Fatalf("Password = %q", config.Password)+ }+}++func TestNewExecutorRequiresDSNAndPassword(t *testing.T) {+ if _, err := NewExecutor("", "password"); err == nil {+ t.Fatal("accepted empty query DSN")+ }+ if _, err := NewExecutor("postgres://db/cyclops", ""); err == nil {+ t.Fatal("accepted empty tenant password")+ }+}+func TestExecutorListsOnlyTenantOwnedNamespaces(t *testing.T) {adminURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")if adminURL == "" {@@ -35,7 +78,7 @@ func TestExecutorListsOnlyTenantOwnedNamespaces(t *testing.T) {if err != nil {t.Fatal(err)}- defer admin.Close()+ t.Cleanup(admin.Close)_, err = admin.Exec(ctx, `delete from k8s_state.resource_state where cluster_id = 'rls-test';insert into k8s_state.resource_state@@ -53,20 +96,107 @@ func TestExecutorListsOnlyTenantOwnedNamespaces(t *testing.T) {_, _ = admin.Exec(context.Background(), `delete from k8s_state.resource_state where cluster_id = 'rls-test'`)})- executor, err := NewExecutor(ctx, urls.Query, urls.RoleAdmin)+ reconcileTestTenantRole(t, admin, "user-alice", "test-tenant-password")++ executor, err := NewExecutor(adminURL, "test-tenant-password")if err != nil {t.Fatal(err)}- defer executor.Close()- validated, err := Validate(`select name from k8s_api.current_resources where cluster_id = 'rls-test' and resource = 'namespaces' order by name`, DefaultLimits())+ writer := &collectingResultWriter{}+ err = executor.Execute(ctx, "user-alice", `select name from k8s_api.current_resources where cluster_id = 'rls-test' and resource = 'namespaces' order by name`, writer)if err != nil {t.Fatal(err)}- result, err := executor.Execute(ctx, "user-alice", false, validated)+ if len(writer.rows) != 1 || writer.rows[0][0] != "alice-ns" {+ t.Fatalf("rows = %#v, want only alice-ns", writer.rows)+ }+}++func TestDirectTenantLoginCannotEscapeTenantIsolation(t *testing.T) {+ adminURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")+ if adminURL == "" {+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run the PostgreSQL direct-login isolation test")+ }+ ctx := context.Background()+ if err := ReconcileFixedRoles(ctx, adminURL, fixedTestRoleURLs(t, adminURL)); err != nil {+ t.Fatal(err)+ }+ if err := Migrate(ctx, adminURL); err != nil {+ t.Fatal(err)+ }+ admin, err := pgxpool.New(ctx, adminURL)+ if err != nil {+ t.Fatal(err)+ }+ t.Cleanup(admin.Close)++ const (+ password = "test-tenant-password"+ alice = "user-alice"+ bob = "user-bob"+ cluster = "direct-login-isolation-test"+ )+ aliceRole := reconcileTestTenantRole(t, admin, alice, password)+ bobRole := reconcileTestTenantRole(t, admin, bob, password)+ if _, err := admin.Exec(ctx, `delete from k8s_state.resource_state where cluster_id = $1`, cluster); err != nil {+ t.Fatal(err)+ }+ if _, err := admin.Exec(ctx, `+ insert into k8s_state.resource_state+ (cluster_id, api_group, resource, namespace, name, capsule_tenant, schema_hash, watch_epoch, observed_sequence, labels, object)+ values+ ($1, '', 'namespaces', '', 'alice-ns', $2, 's', 1, 1, '{}', '{"kind":"Namespace"}'),+ ($1, '', 'namespaces', '', 'bob-ns', $3, 's', 1, 2, '{}', '{"kind":"Namespace"}')+ `, cluster, alice, bob); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), `delete from k8s_state.resource_state where cluster_id = $1`, cluster)+ _, _ = admin.Exec(context.Background(), `drop table if exists tenant_escape`)+ })++ aliceConfig, err := pgx.ParseConfig(adminURL)if err != nil {t.Fatal(err)}- if len(result.Rows) != 1 || result.Rows[0][0] != "alice-ns" {- t.Fatalf("rows = %#v, want only alice-ns", result.Rows)+ aliceConfig.User = aliceRole+ aliceConfig.Password = password+ aliceConn, err := pgx.ConnectConfig(ctx, aliceConfig)+ if err != nil {+ t.Fatal(err)+ }+ defer aliceConn.Close(ctx)++ if _, err = aliceConn.Exec(ctx, "set role "+pgx.Identifier{bobRole}.Sanitize()); err == nil {+ t.Fatal("alice switched to bob's tenant role")+ }++ rows, err := aliceConn.Query(ctx, `+ select name+ from k8s_api.current_resources+ where cluster_id = $1 and resource = 'namespaces'+ order by name+ `, cluster)+ if err != nil {+ t.Fatal(err)+ }+ defer rows.Close()+ var names []string+ for rows.Next() {+ var name string+ if err := rows.Scan(&name); err != nil {+ t.Fatal(err)+ }+ names = append(names, name)+ }+ if err := rows.Err(); err != nil {+ t.Fatal(err)+ }+ if len(names) != 1 || names[0] != "alice-ns" {+ t.Fatalf("rows = %q, want only alice-ns", names)+ }++ if _, err = aliceConn.Exec(ctx, `create table tenant_escape(id integer)`); err == nil {+ t.Fatal("tenant role created a table")}}diff --git a/libs/fleet/backend/statequery/migrations/0001_postgres_state.sql b/libs/fleet/backend/statequery/migrations/0001_postgres_state.sqlindex e6383e39dd..f94174d9a3 100644--- a/libs/fleet/backend/statequery/migrations/0001_postgres_state.sql+++ b/libs/fleet/backend/statequery/migrations/0001_postgres_state.sql@@ -79,6 +79,7 @@ CREATE TABLE k8s_state.resource_schema (CREATE TABLE k8s_state.query_tenant_role (role_name name PRIMARY KEY,capsule_tenant text NOT NULL UNIQUE,+ credential_fingerprint text NOT NULL,created_at timestamptz NOT NULL DEFAULT clock_timestamp());@@ -148,19 +149,34 @@ GRANT USAGE ON SCHEMA k8s_api TO k8s_query_tenant, k8s_query_admin;GRANT SELECT ON k8s_state.resource_state TO k8s_query_tenant, k8s_query_admin;GRANT SELECT ON k8s_api.current_resources TO k8s_query_tenant, k8s_query_admin;-CREATE FUNCTION k8s_state.register_tenant_role(p_role_name name, p_capsule_tenant text)+CREATE FUNCTION k8s_state.register_tenant_role(p_role_name name, p_capsule_tenant text, p_credential_fingerprint text)RETURNS voidLANGUAGE sqlVOLATILESECURITY DEFINERSET search_path = k8s_state, pg_catalogAS $$- INSERT INTO k8s_state.query_tenant_role (role_name, capsule_tenant)- VALUES (p_role_name, p_capsule_tenant)+ INSERT INTO k8s_state.query_tenant_role (role_name, capsule_tenant, credential_fingerprint)+ VALUES (p_role_name, p_capsule_tenant, p_credential_fingerprint)ON CONFLICT (role_name) DO UPDATE- SET capsule_tenant = EXCLUDED.capsule_tenant+ SET capsule_tenant = EXCLUDED.capsule_tenant,+ credential_fingerprint = EXCLUDED.credential_fingerprint$$;-REVOKE ALL ON FUNCTION k8s_state.register_tenant_role(name, text) FROM PUBLIC;+CREATE FUNCTION k8s_state.unregister_tenant_role(p_role_name name)+RETURNS void+LANGUAGE sql+VOLATILE+SECURITY DEFINER+SET search_path = k8s_state, pg_catalog+AS $$+ DELETE FROM k8s_state.query_tenant_role+ WHERE role_name = p_role_name+$$;++REVOKE ALL ON FUNCTION k8s_state.register_tenant_role(name, text, text) FROM PUBLIC;+REVOKE ALL ON FUNCTION k8s_state.unregister_tenant_role(name) FROM PUBLIC;GRANT USAGE ON SCHEMA k8s_state TO k8s_role_admin;-GRANT EXECUTE ON FUNCTION k8s_state.register_tenant_role(name, text) TO k8s_role_admin;+GRANT SELECT ON k8s_state.query_tenant_role TO k8s_role_admin;+GRANT EXECUTE ON FUNCTION k8s_state.register_tenant_role(name, text, text) TO k8s_role_admin;+GRANT EXECUTE ON FUNCTION k8s_state.unregister_tenant_role(name) TO k8s_role_admin;diff --git a/libs/fleet/backend/statequery/roles.go b/libs/fleet/backend/statequery/roles.goindex c2dbb5af28..1979c91b8b 100644--- a/libs/fleet/backend/statequery/roles.go+++ b/libs/fleet/backend/statequery/roles.go@@ -21,7 +21,6 @@ var fixedLoginRoles = []struct {}{{"k8s_state_writer", func(urls FixedRoleURLs) string { return urls.Writer }, "LOGIN INHERIT NOCREATEROLE"},{"k8s_state_exporter", func(urls FixedRoleURLs) string { return urls.Exporter }, "LOGIN INHERIT NOCREATEROLE"},- {"k8s_query_broker", func(urls FixedRoleURLs) string { return urls.Query }, "LOGIN NOINHERIT NOCREATEROLE"},{"k8s_role_admin", func(urls FixedRoleURLs) string { return urls.RoleAdmin }, "LOGIN NOINHERIT CREATEROLE"},}@@ -98,11 +97,13 @@ func ReconcileFixedRoles(ctx context.Context, adminURL string, urls FixedRoleURLreturn err}}+ if err := removeLegacyQueryBroker(ctx, tx); err != nil {+ return err+ }adminIdentifier := pgx.Identifier{adminConfig.User}.Sanitize()for _, statement := range []string{"grant k8s_state_owner to " + adminIdentifier,- "grant k8s_query_admin to k8s_query_broker","grant k8s_query_tenant to k8s_role_admin with admin option",} {if _, err := tx.Exec(ctx, statement); err != nil {@@ -116,6 +117,53 @@ func ReconcileFixedRoles(ctx context.Context, adminURL string, urls FixedRoleURLreturn nil}+func removeLegacyQueryBroker(ctx context.Context, tx pgx.Tx) error {+ var exists bool+ if err := tx.QueryRow(ctx, `select exists(select 1 from pg_roles where rolname = 'k8s_query_broker')`).Scan(&exists); err != nil {+ return fmt.Errorf("check legacy query broker: %w", err)+ }+ if !exists {+ return nil+ }++ rows, err := tx.Query(ctx, `+ select parent.rolname+ from pg_auth_members membership+ join pg_roles parent on parent.oid = membership.roleid+ join pg_roles member on member.oid = membership.member+ where member.rolname = 'k8s_query_broker'+ `)+ if err != nil {+ return fmt.Errorf("list legacy query broker memberships: %w", err)+ }+ memberships := []string{}+ for rows.Next() {+ var roleName string+ if err := rows.Scan(&roleName); err != nil {+ return fmt.Errorf("scan legacy query broker membership: %w", err)+ }+ memberships = append(memberships, roleName)+ }+ if err := rows.Err(); err != nil {+ return fmt.Errorf("iterate legacy query broker memberships: %w", err)+ }+ rows.Close()++ for _, roleName := range memberships {+ statement := "revoke " + pgx.Identifier{roleName}.Sanitize() + " from k8s_query_broker"+ if _, err := tx.Exec(ctx, statement); err != nil {+ return fmt.Errorf("revoke legacy query broker membership: %w", err)+ }+ }+ if _, err := tx.Exec(ctx, "revoke k8s_query_admin from k8s_query_broker"); err != nil {+ return fmt.Errorf("revoke legacy query administrator membership: %w", err)+ }+ if _, err := tx.Exec(ctx, "drop role k8s_query_broker"); err != nil {+ return fmt.Errorf("drop legacy query broker: %w", err)+ }+ return nil+}+func ensureRole(ctx context.Context, tx pgx.Tx, name, attributes, password string) error {var exists boolif err := tx.QueryRow(ctx, `select exists(select 1 from pg_roles where rolname = $1)`, name).Scan(&exists); err != nil {diff --git a/libs/fleet/backend/statequery/roles_pg_test.go b/libs/fleet/backend/statequery/roles_pg_test.goindex 9d4c97efac..022fd38433 100644--- a/libs/fleet/backend/statequery/roles_pg_test.go+++ b/libs/fleet/backend/statequery/roles_pg_test.go@@ -2,10 +2,13 @@ package statequeryimport ("context"+ "crypto/sha256"+ "encoding/hex""net/url""os""testing"+ "github.com/jackc/pgx/v5""github.com/jackc/pgx/v5/pgxpool")@@ -23,7 +26,6 @@ func fixedTestRoleURLs(t *testing.T, adminURL string) FixedRoleURLs {return FixedRoleURLs{Writer: withRole("k8s_state_writer", "test-writer"),Exporter: withRole("k8s_state_exporter", "test-exporter"),- Query: withRole("k8s_query_broker", "test-query"),RoleAdmin: withRole("k8s_role_admin", "test-role-admin"),}}@@ -34,16 +36,38 @@ func TestReconcileFixedRolesCreatesLeastPrivilegeRoles(t *testing.T) {t.Skip("set CYCLOPS_TEST_DATABASE_URL to run the Postgres role test")}ctx := context.Background()- if err := ReconcileFixedRoles(ctx, adminURL, fixedTestRoleURLs(t, adminURL)); err != nil {- t.Fatalf("ReconcileFixedRoles: %v", err)- }-pool, err := pgxpool.New(ctx, adminURL)if err != nil {t.Fatal(err)}defer pool.Close()+ const legacyTenant = "k8s_legacy_query_broker_tenant"+ if _, err := pool.Exec(ctx, "drop role if exists k8s_query_broker"); err != nil {+ t.Fatalf("drop existing query broker: %v", err)+ }+ if _, err := pool.Exec(ctx, "drop role if exists "+legacyTenant); err != nil {+ t.Fatalf("drop existing legacy tenant: %v", err)+ }+ defer func() {+ if _, err := pool.Exec(ctx, "drop role if exists "+legacyTenant); err != nil {+ t.Errorf("drop legacy tenant: %v", err)+ }+ }()+ if _, err := pool.Exec(ctx, "create role "+legacyTenant+" nologin"); err != nil {+ t.Fatalf("create legacy tenant: %v", err)+ }+ if _, err := pool.Exec(ctx, "create role k8s_query_broker login noinherit password 'legacy-broker'"); err != nil {+ t.Fatalf("create legacy query broker: %v", err)+ }+ if _, err := pool.Exec(ctx, "grant "+legacyTenant+" to k8s_query_broker"); err != nil {+ t.Fatalf("grant legacy tenant to query broker: %v", err)+ }++ if err := ReconcileFixedRoles(ctx, adminURL, fixedTestRoleURLs(t, adminURL)); err != nil {+ t.Fatalf("ReconcileFixedRoles: %v", err)+ }+expected := map[string]struct {login, inherit, createRole bool}{@@ -52,7 +76,6 @@ func TestReconcileFixedRolesCreatesLeastPrivilegeRoles(t *testing.T) {"k8s_state_exporter": {true, true, false},"k8s_query_tenant": {false, true, false},"k8s_query_admin": {false, true, false},- "k8s_query_broker": {true, false, false},"k8s_role_admin": {true, false, true},}for role, want := range expected {@@ -65,4 +88,123 @@ func TestReconcileFixedRolesCreatesLeastPrivilegeRoles(t *testing.T) {t.Errorf("role %s flags = login:%t inherit:%t createrole:%t, want %+v", role, login, inherit, createRole, want)}}++ var brokerExists bool+ if err := pool.QueryRow(ctx, `select exists(select 1 from pg_roles where rolname = 'k8s_query_broker')`).Scan(&brokerExists); err != nil {+ t.Fatal(err)+ }+ if brokerExists {+ t.Fatal("legacy query broker still exists")+ }++ var legacyMembershipExists bool+ if err := pool.QueryRow(ctx, `+ select exists (+ select 1+ from pg_auth_members membership+ join pg_roles parent on parent.oid = membership.roleid+ join pg_roles member on member.oid = membership.member+ where parent.rolname = $1 and member.rolname = 'k8s_query_broker'+ )`, legacyTenant).Scan(&legacyMembershipExists); err != nil {+ t.Fatal(err)+ }+ if legacyMembershipExists {+ t.Fatal("legacy query broker membership remains")+ }++ var tenantAdminOption bool+ if err := pool.QueryRow(ctx, `+ select membership.admin_option+ from pg_auth_members membership+ join pg_roles parent on parent.oid = membership.roleid+ join pg_roles member on member.oid = membership.member+ where parent.rolname = 'k8s_query_tenant' and member.rolname = 'k8s_role_admin'+ `).Scan(&tenantAdminOption); err != nil {+ t.Fatalf("query role administrator tenant membership: %v", err)+ }+ if !tenantAdminOption {+ t.Fatal("role administrator lacks admin option for tenant role")+ }+}++func TestReconcileFixedRolesWithoutLegacyQueryBroker(t *testing.T) {+ adminURL := os.Getenv("CYCLOPS_TEST_DATABASE_URL")+ if adminURL == "" {+ t.Skip("set CYCLOPS_TEST_DATABASE_URL to run the Postgres role test")+ }+ ctx := context.Background()+ pool, err := pgxpool.New(ctx, adminURL)+ if err != nil {+ t.Fatal(err)+ }+ defer pool.Close()++ if _, err := pool.Exec(ctx, "drop role if exists k8s_query_broker"); err != nil {+ t.Fatalf("drop existing query broker: %v", err)+ }+ if err := ReconcileFixedRoles(ctx, adminURL, fixedTestRoleURLs(t, adminURL)); err != nil {+ t.Fatalf("ReconcileFixedRoles without legacy broker: %v", err)+ }++ var tenantAdminOption bool+ if err := pool.QueryRow(ctx, `+ select membership.admin_option+ from pg_auth_members membership+ join pg_roles parent on parent.oid = membership.roleid+ join pg_roles member on member.oid = membership.member+ where parent.rolname = 'k8s_query_tenant' and member.rolname = 'k8s_role_admin'+ `).Scan(&tenantAdminOption); err != nil {+ t.Fatalf("query role administrator tenant membership: %v", err)+ }+ if !tenantAdminOption {+ t.Fatal("role administrator lacks admin option for tenant role")+ }+}++func reconcileTestTenantRole(t *testing.T, admin *pgxpool.Pool, tenant, password string) string {+ t.Helper()++ ctx := context.Background()+ role := TenantRoleName(tenant)+ identifier := pgx.Identifier{role}.Sanitize()+ t.Cleanup(func() {+ if _, err := admin.Exec(context.Background(), `select k8s_state.unregister_tenant_role($1)`, role); err != nil {+ t.Errorf("unregister tenant role %s: %v", role, err)+ }+ if _, err := admin.Exec(context.Background(), "drop role if exists "+identifier); err != nil {+ t.Errorf("drop tenant role %s: %v", role, err)+ }+ })+ if _, err := admin.Exec(ctx, "drop role if exists "+identifier); err != nil {+ t.Fatal(err)+ }++ var passwordClause string+ if err := admin.QueryRow(+ ctx,+ `select format(' password %L', $1::text)`,+ password,+ ).Scan(&passwordClause); err != nil {+ t.Fatal(err)+ }+ for _, statement := range []string{+ "create role " + identifier + " login inherit nocreaterole" + passwordClause,+ "grant k8s_query_tenant to " + identifier,+ } {+ if _, err := admin.Exec(ctx, statement); err != nil {+ t.Fatal(err)+ }+ }++ fingerprint := sha256.Sum256([]byte(password))+ if _, err := admin.Exec(+ ctx,+ `select k8s_state.register_tenant_role($1, $2, $3)`,+ role,+ tenant,+ hex.EncodeToString(fingerprint[:]),+ ); err != nil {+ t.Fatal(err)+ }+ return role}diff --git a/libs/fleet/backend/statequery/roles_test.go b/libs/fleet/backend/statequery/roles_test.goindex fa7a12ce72..aea9645e46 100644--- a/libs/fleet/backend/statequery/roles_test.go+++ b/libs/fleet/backend/statequery/roles_test.go@@ -6,15 +6,14 @@ func TestParseFixedRoleURLsRequiresExpectedUsers(t *testing.T) {urls := FixedRoleURLs{Writer: "postgres://k8s_state_writer:[email protected]/cyclops",Exporter: "postgres://k8s_state_exporter:[email protected]/cyclops",- Query: "postgres://k8s_query_broker:[email protected]/cyclops",RoleAdmin: "postgres://k8s_role_admin:[email protected]/cyclops",}credentials, err := parseFixedRoleURLs(urls)if err != nil {t.Fatal(err)}- if got := credentials["k8s_query_broker"]; got != "query" {- t.Fatalf("query broker password = %q", got)+ if got := credentials["k8s_role_admin"]; got != "roles" {+ t.Fatalf("role administrator password = %q", got)}urls.Writer = "postgres://wrong:[email protected]/cyclops"@@ -23,6 +22,21 @@ func TestParseFixedRoleURLsRequiresExpectedUsers(t *testing.T) {}}+func TestParseFixedRoleURLsDoesNotRequireQueryBroker(t *testing.T) {+ urls := FixedRoleURLs{+ Writer: "postgres://k8s_state_writer:writer@db/cyclops",+ Exporter: "postgres://k8s_state_exporter:exporter@db/cyclops",+ RoleAdmin: "postgres://k8s_role_admin:admin@db/cyclops",+ }+ credentials, err := parseFixedRoleURLs(urls)+ if err != nil {+ t.Fatal(err)+ }+ if _, exists := credentials["k8s_query_broker"]; exists {+ t.Fatal("query broker credential remains")+ }+}+func TestParseFixedRoleURLsAllowsAllURLsAbsent(t *testing.T) {credentials, err := parseFixedRoleURLs(FixedRoleURLs{})if err != nil {diff --git a/libs/fleet/backend/statequery/schema_pg_test.go b/libs/fleet/backend/statequery/schema_pg_test.goindex b777d70ad4..55a7a53286 100644--- a/libs/fleet/backend/statequery/schema_pg_test.go+++ b/libs/fleet/backend/statequery/schema_pg_test.go@@ -47,6 +47,31 @@ func TestMigrateCreatesStateSchemaAndRLS(t *testing.T) {}}+ for _, column := range []string{"role_name", "capsule_tenant", "credential_fingerprint", "created_at"} {+ var exists bool+ err := pool.QueryRow(ctx, `+ select exists (+ select 1+ from information_schema.columns+ where table_schema = 'k8s_state'+ and table_name = 'query_tenant_role'+ and column_name = $1+ )`, column).Scan(&exists)+ if err != nil || !exists {+ t.Fatalf("query_tenant_role column %s exists=%t err=%v", column, exists, err)+ }+ }++ for _, function := range []string{+ "k8s_state.register_tenant_role(name,text,text)",+ "k8s_state.unregister_tenant_role(name)",+ } {+ var exists bool+ if err := pool.QueryRow(ctx, "select to_regprocedure($1) is not null", function).Scan(&exists); err != nil || !exists {+ t.Fatalf("function %s exists=%t err=%v", function, exists, err)+ }+ }+var forced boolif err := pool.QueryRow(ctx, `select relforcerowsecurity from pg_class where oid = 'k8s_state.resource_state'::regclass`).Scan(&forced); err != nil {t.Fatal(err)diff --git a/libs/fleet/backend/statequery/schema_test.go b/libs/fleet/backend/statequery/schema_test.goindex fb32996f39..89b980d267 100644--- a/libs/fleet/backend/statequery/schema_test.go+++ b/libs/fleet/backend/statequery/schema_test.go@@ -6,7 +6,7 @@ import ("testing")-func TestEmbeddedMigrationDefinesStateSchemaAndRLS(t *testing.T) {+func TestMigrationContainsRequiredObjects(t *testing.T) {migration, err := migrationSQL("0001_postgres_state.sql")if err != nil {t.Fatal(err)@@ -24,11 +24,18 @@ func TestEmbeddedMigrationDefinesStateSchemaAndRLS(t *testing.T) {"resource = 'namespaces'","CREATE VIEW k8s_api.current_resources","GRANT SELECT ON k8s_api.current_resources TO k8s_query_tenant, k8s_query_admin",+ "credential_fingerprint text NOT NULL",+ "CREATE FUNCTION k8s_state.register_tenant_role(p_role_name name, p_capsule_tenant text, p_credential_fingerprint text)",+ "CREATE FUNCTION k8s_state.unregister_tenant_role(p_role_name name)",+ "GRANT SELECT ON k8s_state.query_tenant_role TO k8s_role_admin",} {if !strings.Contains(migration, required) {t.Errorf("migration missing %q", required)}}+ if strings.Contains(migration, "k8s_query_broker") {+ t.Fatal("migration retains the removed query broker")+ }}func TestEmbeddedMigrationsAreSortedAndDigested(t *testing.T) {diff --git a/libs/fleet/backend/statequery/validator.go b/libs/fleet/backend/statequery/validator.godeleted file mode 100644index 6213370481..0000000000--- a/libs/fleet/backend/statequery/validator.go+++ /dev/null@@ -1,139 +0,0 @@-package statequery--import (- "errors"- "fmt"- "strings"-- pg_query "github.com/pganalyze/pg_query_go/v6"- "google.golang.org/protobuf/reflect/protoreflect"-)--var ErrInvalidQuery = errors.New("invalid state query")--type Limits struct {- MaxRows int- TimeoutMS int- MaxSQLBytes int-}--type ValidatedQuery struct {- SQL string- MaxRows int- TimeoutMS int-}--func DefaultLimits() Limits {- return Limits{MaxRows: 1000, TimeoutMS: 5000, MaxSQLBytes: 65536}-}--func Validate(sql string, limits Limits) (ValidatedQuery, error) {- sql = strings.TrimSpace(sql)- if sql == "" {- return ValidatedQuery{}, fmt.Errorf("%w: SQL is empty", ErrInvalidQuery)- }- if limits.MaxRows <= 0 || limits.TimeoutMS <= 0 || limits.MaxSQLBytes <= 0 {- return ValidatedQuery{}, fmt.Errorf("%w: invalid server limits", ErrInvalidQuery)- }- if len(sql) > limits.MaxSQLBytes {- return ValidatedQuery{}, fmt.Errorf("%w: SQL exceeds byte limit", ErrInvalidQuery)- }-- tree, err := pg_query.Parse(sql)- if err != nil {- return ValidatedQuery{}, fmt.Errorf("%w: parse failed", ErrInvalidQuery)- }- if len(tree.Stmts) != 1 || tree.Stmts[0].Stmt.GetSelectStmt() == nil {- return ValidatedQuery{}, fmt.Errorf("%w: exactly one SELECT is required", ErrInvalidQuery)- }-- ctes := map[string]bool{}- if err := walkMessage(tree.ProtoReflect(), func(message protoreflect.Message) error {- if cte, ok := message.Interface().(*pg_query.CommonTableExpr); ok {- ctes[cte.GetCtename()] = true- }- return nil- }); err != nil {- return ValidatedQuery{}, err- }- if err := walkMessage(tree.ProtoReflect(), func(message protoreflect.Message) error {- switch value := message.Interface().(type) {- case *pg_query.InsertStmt, *pg_query.UpdateStmt, *pg_query.DeleteStmt,- *pg_query.MergeStmt, *pg_query.CopyStmt, *pg_query.VariableSetStmt,- *pg_query.TransactionStmt, *pg_query.CreateStmt, *pg_query.AlterTableStmt,- *pg_query.DropStmt, *pg_query.TruncateStmt, *pg_query.CallStmt,- *pg_query.DoStmt, *pg_query.IntoClause:- return fmt.Errorf("%w: writable or utility statement", ErrInvalidQuery)- case *pg_query.RangeVar:- if value.GetSchemaname() == "" && ctes[value.GetRelname()] {- return nil- }- if value.GetSchemaname() != "k8s_api" || value.GetRelname() != "current_resources" {- return fmt.Errorf("%w: relation is not allowlisted", ErrInvalidQuery)- }- case *pg_query.FuncCall:- name := functionName(value)- if !allowedFunction(name) {- return fmt.Errorf("%w: function %s is not allowlisted", ErrInvalidQuery, name)- }- }- return nil- }); err != nil {- return ValidatedQuery{}, err- }-- inner := strings.TrimSuffix(sql, ";")- return ValidatedQuery{- SQL: fmt.Sprintf("SELECT * FROM (%s) AS cyclops_state_query LIMIT %d", inner, limits.MaxRows+1),- MaxRows: limits.MaxRows,- TimeoutMS: limits.TimeoutMS,- }, nil-}--func walkMessage(message protoreflect.Message, visit func(protoreflect.Message) error) error {- if !message.IsValid() {- return nil- }- if err := visit(message); err != nil {- return err- }- var walkErr error- message.Range(func(field protoreflect.FieldDescriptor, value protoreflect.Value) bool {- if field.IsList() && field.Kind() == protoreflect.MessageKind {- list := value.List()- for index := 0; index < list.Len(); index++ {- if err := walkMessage(list.Get(index).Message(), visit); err != nil {- walkErr = err- return false- }- }- return true- }- if field.Kind() == protoreflect.MessageKind {- walkErr = walkMessage(value.Message(), visit)- return walkErr == nil- }- return true- })- return walkErr-}--func functionName(call *pg_query.FuncCall) string {- parts := make([]string, 0, len(call.GetFuncname()))- for _, node := range call.GetFuncname() {- if value := node.GetString_(); value != nil {- parts = append(parts, strings.ToLower(value.GetSval()))- }- }- return strings.Join(parts, ".")-}--func allowedFunction(name string) bool {- switch name {- case "count", "min", "max", "sum", "avg", "coalesce", "lower", "upper",- "length", "jsonb_typeof", "jsonb_path_exists", "date_trunc":- return true- default:- return false- }-}diff --git a/libs/fleet/backend/statequery/validator_test.go b/libs/fleet/backend/statequery/validator_test.godeleted file mode 100644index f3a9ffadd2..0000000000--- a/libs/fleet/backend/statequery/validator_test.go+++ /dev/null@@ -1,59 +0,0 @@-package statequery--import (- "strings"- "testing"-)--func TestValidateRejectsUnsafeSQL(t *testing.T) {- for _, query := range []string{- "select 1; select 2",- "delete from k8s_api.current_resources",- "with gone as (delete from k8s_api.current_resources returning *) select * from gone",- "select * into leaked from k8s_api.current_resources",- "copy k8s_api.current_resources to stdout",- "set role k8s_query_admin",- "select set_config('role', 'k8s_query_admin', false)",- "select * from pg_catalog.pg_roles",- "select pg_sleep(60)",- "select * from public.current_resources",- "select * from current_resources",- } {- t.Run(query, func(t *testing.T) {- if _, err := Validate(query, DefaultLimits()); err == nil {- t.Fatalf("accepted unsafe SQL: %s", query)- }- })- }-}--func TestValidateAcceptsReadOnlyStateQueries(t *testing.T) {- for _, query := range []string{- `select name, object->'metadata'->>'name' from k8s_api.current_resources order by name`,- `with owned as (select * from k8s_api.current_resources where resource = 'namespaces') select count(*) from owned`,- `select capsule_tenant, count(*) from k8s_api.current_resources group by capsule_tenant`,- `select name from k8s_api.current_resources where labels @> '{"team":"a"}'::jsonb`,- } {- t.Run(query, func(t *testing.T) {- validated, err := Validate(query, Limits{MaxRows: 25, TimeoutMS: 5000, MaxSQLBytes: 65536})- if err != nil {- t.Fatal(err)- }- if !strings.Contains(validated.SQL, "LIMIT 26") {- t.Fatalf("validated SQL does not include truncation sentinel: %s", validated.SQL)- }- if validated.MaxRows != 25 {- t.Fatalf("MaxRows = %d", validated.MaxRows)- }- })- }-}--func TestValidateEnforcesInputLimits(t *testing.T) {- if _, err := Validate("", DefaultLimits()); err == nil {- t.Fatal("accepted empty SQL")- }- if _, err := Validate("select * from k8s_api.current_resources", Limits{MaxRows: 0, TimeoutMS: 1, MaxSQLBytes: 1}); err == nil {- t.Fatal("accepted SQL exceeding byte limit")- }-}