Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(tsql)!: resolve UPDATE/DELETE targets through the FROM clause (#21653)
Vincent Huangfec9a2a82043
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex dd78e642a4..ff72907b8b 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -2001,17 +2001,7 @@ func (s *SQLService) authorizeWriteTargets(envByDatabase[t.database] = env}- attributes := map[string]any{- common.CELAttributeRequestTime: requestTime,- common.CELAttributeResourceDatabase: databaseFullName,- common.CELAttributeResourceEnvironmentID: env,- }- if !useDatabaseLevel {- attributes[common.CELAttributeResourceTableName] = t.table- if t.schema != "" {- attributes[common.CELAttributeResourceSchemaName] = t.schema- }- }+ attributes := writeTargetAttributes(requestTime, databaseFullName, env, t, useDatabaseLevel)allowed, err := s.hasDatabaseAccessRights(ctx, user, perm, attributes, iamPolicies...)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to check access control for target %q: %v", deniedResource, err))@@ -2023,6 +2013,23 @@ func (s *SQLService) authorizeWriteTargets(return deniedResources, nil}+// writeTargetAttributes returns the attributes a grant condition is evaluated against+// for write target t; a database-level check carries no table or schema.+func writeTargetAttributes(requestTime time.Time, databaseFullName, env string, t writeTargetResource, databaseLevel bool) map[string]any {+ attributes := map[string]any{+ common.CELAttributeRequestTime: requestTime,+ common.CELAttributeResourceDatabase: databaseFullName,+ common.CELAttributeResourceEnvironmentID: env,+ }+ if !databaseLevel {+ attributes[common.CELAttributeResourceTableName] = t.table+ if t.schema != "" {+ attributes[common.CELAttributeResourceSchemaName] = t.schema+ }+ }+ return attributes+}+// formatWriteTargetResource renders a denied write target as// instances/i/databases/d[/schemas/s]/tables/t; the schema segment is omitted when unknown.func formatWriteTargetResource(databaseFullName, schema, table string) string {@@ -2048,7 +2055,9 @@ type writeTargetResource struct {// Some engines' extractors report auxiliary tables referenced by the change (e.g.// the joined/using tables of an UPDATE … JOIN … / DELETE … USING …) alongside the// mutated table, others only the primary target; either way this can only ever-// over-restrict (fail-closed), never under-restrict.+// over-restrict (fail-closed), never under-restrict. The exception is a SQL Server target+// left as written (BOT-158, BOT-160): it is checked as a table of that name in the request+// database.//// DDL on a non-table object (view/procedure/function/trigger/…) has no table to scope. When// such DDL names an EXPLICIT target database (e.g. CREATE VIEW other_db.v), the extractordiff --git a/backend/api/v1/sql_service_schema_resolution_test.go b/backend/api/v1/sql_service_schema_resolution_test.goindex 6dc0e877d7..9b0173c645 100644--- a/backend/api/v1/sql_service_schema_resolution_test.go+++ b/backend/api/v1/sql_service_schema_resolution_test.go@@ -2,12 +2,14 @@ package v1import ("testing"+ "time"metadatapb "github.com/bytebase/omni/metadata""github.com/stretchr/testify/require"storepb "github.com/bytebase/bytebase/backend/generated-go/store"parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/store""github.com/bytebase/bytebase/backend/store/model")@@ -94,3 +96,71 @@ func TestWriteTargetsFromChangeSummaryRefusesSkippedStatements(t *testing.T) {)require.Nil(t, writeTargetsFromChangeSummary(extract("CREATE OR REPLACE TABLE other_db.t (a INT);")))}++func TestMSSQLDMLWriteTargetGrantConditions(t *testing.T) {+ t.Parallel()+ dbMeta := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{+ Name: "db",+ Schemas: []*metadatapb.SchemaMetadata{{+ Name: "dbo",+ Tables: []*metadatapb.TableMetadata{{Name: "Orders"}, {Name: "Customers"}},+ }},+ }, nil, nil, storepb.Engine_MSSQL, false /* isObjectCaseSensitive, as store.IsObjectCaseSensitive reports SQL Server */)+ instance := &store.InstanceMessage{ResourceID: "i"}++ targets := func(statement string) []writeTargetResource {+ stmts, err := parserbase.ParseStatements(storepb.Engine_MSSQL, statement)+ require.NoError(t, err, statement)+ changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MSSQL, "db",+ schemaForWriteTargetResolution(storepb.Engine_MSSQL, "db", ""), dbMeta, parserbase.ExtractASTs(stmts), statement)+ require.NoError(t, err, statement)+ return writeTargetsFromChangeSummary(changeSummary)+ }+ authorized := func(grant string, target writeTargetResource) bool {+ databaseFullName := formatDatabaseResourceName(instance, &store.DatabaseMessage{InstanceID: "i", DatabaseName: target.database})+ ok, err := evaluateQueryExportPolicyCondition(grant, writeTargetAttributes(time.Now(), databaseFullName, "prod", target, false))+ return err == nil && ok+ }+ const (+ ordersGrant = `resource.database == "instances/i/databases/db" && resource.table_name in ["Orders"]`+ uiOrdersGrant = `resource.database == "instances/i/databases/db" && resource.schema_name == "dbo" && resource.table_name in ["Orders"]`+ aliasGrant = `resource.database == "instances/i/databases/db" && resource.table_name in ["o"]`+ customersGrant = `resource.database == "instances/i/databases/db" && resource.table_name in ["Customers"]`+ )++ aliased := targets(`UPDATE o SET o.status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "db", schema: "dbo", table: "Orders"}}, aliased)+ require.True(t, authorized(ordersGrant, aliased[0]))+ require.True(t, authorized(uiOrdersGrant, aliased[0]), "the aliased table's schema is known, so a schema-scoped grant matches")+ require.False(t, authorized(aliasGrant, aliased[0]))+ require.False(t, authorized(customersGrant, aliased[0]))++ require.Equal(t, []writeTargetResource{{database: "db", table: "Orders"}},+ targets(`DELETE o FROM Orders AS o WHERE o.id = 1;`))++ // The alias shadows the real table of the same name, so the write goes to Orders.+ shadowing := targets(`UPDATE Customers SET status = 'x' FROM dbo.Orders AS Customers WHERE Customers.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "db", schema: "dbo", table: "Orders"}}, shadowing)+ require.False(t, authorized(customersGrant, shadowing[0]))++ // A FROM table in another database, aliased or not, is gated by that database, not the request one.+ crossDatabase := targets(`UPDATE o SET o.status = 'x' FROM otherdb.dbo.Orders AS o WHERE o.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "otherdb", schema: "dbo", table: "Orders"}}, crossDatabase)+ require.False(t, authorized(ordersGrant, crossDatabase[0]))+ unaliasedCrossDatabase := targets(`UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders WHERE Orders.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "otherdb", schema: "dbo", table: "Orders"}}, unaliasedCrossDatabase)+ require.False(t, authorized(ordersGrant, unaliasedCrossDatabase[0]))++ otherSchema := targets(`UPDATE Orders SET status = 'x' FROM sales.Orders WHERE Orders.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "db", schema: "sales", table: "Orders"}}, otherSchema)+ require.False(t, authorized(uiOrdersGrant, otherSchema[0]))++ qualified := targets(`UPDATE dbo.Orders SET status = 'x' FROM dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "db", schema: "dbo", table: "Orders"}}, qualified)+ require.False(t, authorized(customersGrant, qualified[0]))++ // Exact match: a case-insensitive database writes Orders here (BOT-158); a case-sensitive one writes table O.+ caseVariant := targets(`UPDATE O SET status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`)+ require.Equal(t, []writeTargetResource{{database: "db", table: "O"}}, caseVariant)+ require.False(t, authorized(ordersGrant, caseVariant[0]))+}diff --git a/backend/component/review/evaluator.go b/backend/component/review/evaluator.goindex 5f92a0e3e1..7d1d0fc43c 100644--- a/backend/component/review/evaluator.go+++ b/backend/component/review/evaluator.go@@ -763,18 +763,7 @@ func buildCELVariablesForDatabaseChange(ctx context.Context, stores *store.Store}report := result.GetSqlSummaryReport()-- // Calculate table rows from changed resources- var tableRows int64- var tableNames []string- for _, db := range report.GetChangedResources().GetDatabases() {- for _, sc := range db.GetSchemas() {- for _, tb := range sc.GetTables() {- tableRows += tb.GetTableRows()- tableNames = append(tableNames, tb.Name)- }- }- }+ tableNames, tableRows := changedTables(report)celVars[common.CELAttributeStatementAffectedRows] = report.AffectedRowscelVars[common.CELAttributeStatementTableRows] = tableRows@@ -1180,6 +1169,22 @@ func statementTypesFromParser(engine storepb.Engine, statement string) []storepbreturn statementTypes}+// changedTables returns the names of the tables a summary report changes and their+// total row count.+func changedTables(report *storepb.PlanCheckRunResult_Result_SqlSummaryReport) ([]string, int64) {+ var names []string+ var rows int64+ for _, db := range report.GetChangedResources().GetDatabases() {+ for _, sc := range db.GetSchemas() {+ for _, tb := range sc.GetTables() {+ rows += tb.GetTableRows()+ names = append(names, tb.Name)+ }+ }+ }+ return names, rows+}+// expandCELVars creates CEL variable maps for each combination of statement types and table names.func expandCELVars(base map[string]any, statementTypes []storepb.StatementType, tableNames []string) []map[string]any {if len(statementTypes) == 0 {diff --git a/backend/component/review/evaluator_test.go b/backend/component/review/evaluator_test.goindex edde5f1d84..7cff25c9ef 100644--- a/backend/component/review/evaluator_test.go+++ b/backend/component/review/evaluator_test.go@@ -1157,3 +1157,56 @@ func TestApprovalRuleMatchesOceanBaseSummaryReport(t *testing.T) {})}}++func TestApprovalRuleMatchesMSSQLAliasTarget(t *testing.T) {+ strict := &storepb.WorkspaceApprovalSetting_Rule{+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,+ Condition: &expr.Expr{Expression: `statement.sql_type == "UPDATE" && resource.table_name.matches("(?i)^(orders)$")`},+ Template: &storepb.ApprovalTemplate{Title: "Trigger tables"},+ }+ general := &storepb.WorkspaceApprovalSetting_Rule{+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,+ Condition: &expr.Expr{Expression: "true"},+ Template: &storepb.ApprovalTemplate{Title: "General"},+ }+ tests := []struct {+ name string+ statement string+ wantTitle string+ }{+ {"aliased UPDATE of a listed table", `UPDATE o SET o.status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`, "Trigger tables"},+ {"alias named like a listed table writes another table", `UPDATE Orders SET name = 'x' FROM dbo.Customers AS Orders WHERE Orders.id = 1;`, "General"},+ {"UPDATE of an unlisted table", `UPDATE dbo.Customers SET name = 'x' WHERE id = 1;`, "General"},+ }+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ a := require.New(t)+ stmts, err := parserbase.ParseStatements(storepb.Engine_MSSQL, tt.statement)+ a.NoError(err)+ asts := parserbase.ExtractASTs(stmts)+ statementTypes, err := plancheck.SummaryStatementTypes(storepb.Engine_MSSQL, asts)+ a.NoError(err)+ changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MSSQL, "db", "dbo", nil, asts, tt.statement)+ a.NoError(err)++ report := &storepb.PlanCheckRunResult_Result_SqlSummaryReport{+ StatementTypes: statementTypes,+ ChangedResources: changeSummary.ChangedResources.Build(),+ }+ tableNames, _ := changedTables(report)+ celVars := expandCELVars(map[string]any{+ common.CELAttributeResourceEnvironmentID: "prod",+ common.CELAttributeResourceProjectID: "project",+ common.CELAttributeResourceDBEngine: storepb.Engine_MSSQL.String(),+ common.CELAttributeStatementText: tt.statement,+ }, report.StatementTypes, tableNames)++ template, err := getApprovalTemplate(&storepb.WorkspaceApprovalSetting{+ Rules: []*storepb.WorkspaceApprovalSetting_Rule{strict, general},+ }, storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE, celVars)+ a.NoError(err)+ a.NotNil(template)+ a.Equal(tt.wantTitle, template.Title)+ })+ }+}diff --git a/backend/plugin/parser/tsql/resource_change.go b/backend/plugin/parser/tsql/resource_change.goindex b39ed043f0..c874801f39 100644--- a/backend/plugin/parser/tsql/resource_change.go+++ b/backend/plugin/parser/tsql/resource_change.go@@ -123,13 +123,13 @@ func extractChangedResources(currentDatabase string, currentSchema string, dbMetcase *ast.UpdateStmt:if ref, ok := n.Relation.(*ast.TableRef); ok {- addTable(ref, false)+ addTable(resolveDMLWriteTarget(ref, n.FromClause, n.WithClause), false)}addDML(omniAST.Text)case *ast.DeleteStmt:if ref, ok := n.Relation.(*ast.TableRef); ok {- addTable(ref, false)+ addTable(resolveDMLWriteTarget(ref, n.FromClause, n.WithClause), false)}addDML(omniAST.Text)@@ -179,6 +179,54 @@ func extractChangedResources(currentDatabase string, currentSchema string, dbMet}, nil}+// resolveDMLWriteTarget returns the table an UPDATE/DELETE target writes. SQL Server binds an+// unqualified target to the FROM table with that exposed name: its alias, or its own name when+// it has none. A qualified target names its own table, even when a FROM entry is aliased to its+// bare name. Synced metadata reports every SQL Server database as case-insensitive, even under a+// case-sensitive collation, so a target binds only when both collations agree: the FROM match is+// exact and the CTE check folds case. Other targets stay as written, such as a differently cased+// name (BOT-158) and a CTE or derived-table target (BOT-160).+func resolveDMLWriteTarget(target *ast.TableRef, fromClause *ast.List, withClause *ast.WithClause) *ast.TableRef {+ if target.Server != "" || target.Database != "" || target.Schema != "" || fromClause == nil {+ return target+ }+ source := tableByExposedName(fromClause, target.Object)+ if source == nil || isCTETarget(source, withClause, false /* caseSensitive */) {+ return target+ }+ return source+}++func tableByExposedName(node ast.Node, name string) *ast.TableRef {+ switch n := node.(type) {+ case *ast.List:+ for _, item := range n.Items {+ if ref := tableByExposedName(item, name); ref != nil {+ return ref+ }+ }+ case *ast.TableRef:+ if n.Alias == name || (n.Alias == "" && n.Object == name) {+ return n+ }+ case *ast.AliasedTableRef:+ // omni wraps an unaliased table that has TABLESAMPLE in an AliasedTableRef.+ if n.Alias == "" {+ return tableByExposedName(n.Table, name)+ }+ if ref, ok := n.Table.(*ast.TableRef); ok && n.Alias == name {+ return ref+ }+ case *ast.JoinClause:+ if ref := tableByExposedName(n.Left, name); ref != nil {+ return ref+ }+ return tableByExposedName(n.Right, name)+ default:+ }+ return nil+}+func omniTableRefTriple(ref *ast.TableRef, defaultDatabase, defaultSchema string) (string, string, string) {if ref == nil {return defaultDatabase, defaultSchema, ""diff --git a/backend/plugin/parser/tsql/resource_change_test.go b/backend/plugin/parser/tsql/resource_change_test.goindex 502c78bba8..ecc427e174 100644--- a/backend/plugin/parser/tsql/resource_change_test.go+++ b/backend/plugin/parser/tsql/resource_change_test.go@@ -10,6 +10,60 @@ import ("github.com/bytebase/bytebase/backend/store/model")+// extractMSSQL returns the built projection: what approval and write authorization read,+// without the embedded metadata pointer.+func extractMSSQL(t *testing.T, statement string) *storepb.ChangedResources {+ t.Helper()+ stmts, err := base.ParseStatements(storepb.Engine_MSSQL, statement)+ require.NoError(t, err, statement)+ got, err := extractChangedResources("DB", "dbo", nil /* dbMetadata */, base.ExtractASTs(stmts), statement)+ require.NoError(t, err, statement)+ return got.ChangedResources.Build()+}++func TestExtractChangedResources_DMLWriteTarget(t *testing.T) {+ tests := []struct {+ name string+ statement string+ database string+ schema string+ table string+ }{+ {"alias", `UPDATE o SET o.status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`, "DB", "dbo", "Orders"},+ {"alias without AS", `UPDATE o SET status = 'x' FROM dbo.Orders o WHERE o.id = 1;`, "DB", "dbo", "Orders"},+ {"alias in DELETE", `DELETE o FROM dbo.Orders AS o WHERE o.id = 1;`, "DB", "dbo", "Orders"},+ {"alias on the right of a JOIN", `UPDATE o SET o.status = 'x' FROM dbo.Customers AS c JOIN dbo.Orders AS o ON o.id = c.id WHERE c.id = 1;`, "DB", "dbo", "Orders"},+ {"alias beside an APPLY", `UPDATE o SET o.status = 'x' FROM dbo.Orders AS o CROSS APPLY (SELECT TOP 1 c.id FROM dbo.Customers AS c WHERE c.id = o.id) AS a WHERE o.id = 1;`, "DB", "dbo", "Orders"},+ {"alias shadows a table of its name", `UPDATE Customers SET status = 'x' FROM dbo.Orders AS Customers WHERE Customers.id = 1;`, "DB", "dbo", "Orders"},+ {"alias of a table in another database", `UPDATE o SET o.status = 'x' FROM otherdb.dbo.Orders AS o WHERE o.id = 1;`, "otherdb", "dbo", "Orders"},+ {"unaliased table in another database", `UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders WHERE Orders.id = 1;`, "otherdb", "dbo", "Orders"},+ {"unaliased table in another schema", `UPDATE Orders SET status = 'x' FROM sales.Orders WHERE Orders.id = 1;`, "DB", "sales", "Orders"},+ {"unaliased table in DELETE FROM", `DELETE FROM Orders FROM otherdb.dbo.Orders WHERE Orders.id = 1;`, "otherdb", "dbo", "Orders"},+ {"unaliased join operand", `UPDATE Orders SET status = 'x' FROM dbo.Customers AS c LEFT JOIN otherdb.dbo.Orders ON c.id = Orders.id WHERE c.id = 1;`, "otherdb", "dbo", "Orders"},+ {"unaliased sampled table", `UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders TABLESAMPLE (100 PERCENT) WHERE Orders.id = 1;`, "otherdb", "dbo", "Orders"},+ {"aliased table hides its own name", `UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders AS x WHERE x.id = 1;`, "DB", "dbo", "Orders"},+ {"qualified target ignores an alias of its bare name", `UPDATE dbo.Orders SET status = 'x' FROM dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`, "DB", "dbo", "Orders"},+ {"qualified DELETE target ignores an alias of its bare name", `DELETE dbo.Orders FROM dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`, "DB", "dbo", "Orders"},+ {"qualified target in another database ignores an alias of its bare name", `UPDATE otherdb.dbo.Orders SET status = 'x' FROM otherdb.dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`, "otherdb", "dbo", "Orders"},+ // The server part is dropped, as for any linked-server name (BYT-10235).+ {"server-qualified target ignores an alias of its bare name", `UPDATE srv...Orders SET status = 'x' FROM srv...Orders AS t JOIN dbo.Customers AS Orders ON Orders.id = t.id WHERE t.id = 1;`, "DB", "dbo", "Orders"},+ // A case-insensitive database binds the next two to the FROM table (BOT-158); a+ // case-sensitive one does not.+ {"differently cased alias stays as written", `UPDATE O SET status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`, "DB", "dbo", "O"},+ {"differently cased table name stays as written", `UPDATE ORDERS SET status = 'x' FROM otherdb.dbo.Orders WHERE Orders.id = 1;`, "DB", "dbo", "ORDERS"},+ {"alias of a CTE stays as written", `WITH c AS (SELECT id, status FROM dbo.Orders) UPDATE x SET status = 'v' FROM c AS x WHERE x.id = 1;`, "DB", "dbo", "x"},+ {"alias of a differently cased CTE name stays as written", `WITH c AS (SELECT id, status FROM dbo.Orders) UPDATE x SET status = 'v' FROM C AS x WHERE x.id = 1;`, "DB", "dbo", "x"},+ {"alias of a derived table stays as written", `UPDATE d SET status = 'x' FROM (SELECT * FROM dbo.Orders) AS d WHERE d.id = 1;`, "DB", "dbo", "d"},+ }+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ want := model.NewChangedResources(nil)+ want.AddTable(tt.database, tt.schema, &storepb.ChangedResourceTable{Name: tt.table}, false)+ require.Equal(t, want.Build(), extractMSSQL(t, tt.statement))+ })+ }+}+func TestExtractChangedResources(t *testing.T) {statement := `CREATE TABLE t1 (c1 INT);DROP TABLE t1;