Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

Update state_query.go (#6662)

r33drichards6d88a62fcbae
diff --git a/libs/fleet/backend/auth/authz.rego b/libs/fleet/backend/auth/authz.rego
index 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.rego
index 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.go
index 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.go
index 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.mod
index 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.5
github.com/open-feature/go-sdk v1.17.0
github.com/open-policy-agent/opa v0.69.0
- github.com/pganalyze/pg_query_go/v6 v6.2.2
github.com/prometheus/client_golang v1.20.4
github.com/spf13/cobra v1.10.2
github.com/spf13/pflag v1.0.10
@@ -115,7 +114,7 @@ require (
golang.org/x/net v0.44.0 // indirect
golang.org/x/sys v0.36.0 // indirect
golang.org/x/tools v0.37.0 // indirect
- google.golang.org/protobuf v1.34.2
+ google.golang.org/protobuf v1.34.2 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
sigs.k8s.io/yaml v1.4.0 // indirect
)
diff --git a/libs/fleet/backend/go.sum b/libs/fleet/backend/go.sum
index 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.go
index 00b3a8a037..a0fdbaa133 100644
--- a/libs/fleet/backend/handlers/handlers.go
+++ b/libs/fleet/backend/handlers/handlers.go
@@ -4,7 +4,6 @@ package handlers
import (
"bufio"
- "context"
"encoding/json"
"fmt"
"net"
@@ -25,14 +24,12 @@ type Handlers struct {
AuthCfg config.AuthConfiguration
KC config.KeycloakConfiguration
Stripe config.StripeConfiguration
- StateQuery config.StateQueryConfiguration
Billing BillingService
WebhookVerifier WebhookVerifier
GitHubTrustPolicies 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.go
index 3e6aa344c8..efe3280ca8 100644
--- a/libs/fleet/backend/handlers/state_query.go
+++ b/libs/fleet/backend/handlers/state_query.go
@@ -3,75 +3,113 @@ package handlers
import (
"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.go
index 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 [][]any
err 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.go
index 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 = executor
slog.Info("kubernetes state query: query endpoint enabled")
}
diff --git a/libs/fleet/backend/main_test.go b/libs/fleet/backend/main_test.go
index 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.go
index 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 owner
from 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.go
index 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.go
index 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.sql
index 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 void
LANGUAGE sql
VOLATILE
SECURITY DEFINER
SET search_path = k8s_state, pg_catalog
AS $$
- 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.go
index 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 FixedRoleURL
return 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 FixedRoleURL
return 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 bool
if 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.go
index 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 statequery
import (
"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.go
index 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.go
index 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 bool
if 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.go
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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")
- }
-}