Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(kingbase): recover view source hidden from non-owner roles (#13027)

ezreal7ea4031465d2
diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.go
index 3905c2e702..c5dc3414ab 100644
--- a/agents/drivers/kingbase-go/kingbase_metadata.go
+++ b/agents/drivers/kingbase-go/kingbase_metadata.go
@@ -2787,25 +2787,7 @@ func (s *server) getObjectSourceForRelation(schema, name, objectType, relationNa
source := ""
kind := strings.ToUpper(objectType)
if kind == "VIEW" {
- if s.mode.mysqlCompat {
- err = s.requireDBQueryRow("SELECT view_definition FROM information_schema.views WHERE table_schema = "+quoteLiteral(effective)+" AND table_name = "+quoteLiteral(name), &source)
- } else {
- catalog, prefix, function := "sys_catalog", "sys", "sys_get_viewdef"
- if s.mode.postgresCatalog {
- catalog, prefix, function = "pg_catalog", "pg", "pg_get_viewdef"
- } else if s.usePgViewDefinition {
- function = "pg_get_viewdef"
- }
- querySource := func(definitionFunction string) error {
- query := fmt.Sprintf("SELECT %s(c.oid) FROM %s.%s_class c JOIN %s.%s_namespace n ON n.oid=c.relnamespace WHERE n.nspname=%s AND c.relname=%s LIMIT 1", definitionFunction, catalog, prefix, catalog, prefix, quoteLiteral(effective), quoteLiteral(name))
- return s.requireDBQueryRow(query, &source)
- }
- err = querySource(function)
- if err != nil && function == "sys_get_viewdef" && isUndefinedFunction(err, function) {
- s.usePgViewDefinition = true
- err = querySource("pg_get_viewdef")
- }
- }
+ source, err = s.getViewSource(effective, name)
} else if kind == "MATERIALIZED_VIEW" {
source, err = s.getMaterializedViewSource(effective, name)
} else if kind == "FUNCTION" || kind == "PROCEDURE" {
@@ -2863,6 +2845,60 @@ func (s *server) getObjectSourceForRelation(schema, name, objectType, relationNa
return result, nil
}
+func (s *server) getViewSource(schema, name string) (string, error) {
+ querySource := func(query string) (string, error) {
+ var source sql.NullString
+ if err := s.requireDBQueryRow(query, &source); err != nil {
+ return "", err
+ }
+ if !source.Valid || strings.TrimSpace(source.String) == "" {
+ return "", sql.ErrNoRows
+ }
+ return source.String, nil
+ }
+ if s.mode.mysqlCompat {
+ // information_schema can expose a view while hiding its definition from
+ // a non-owner with SELECT privileges. Try the catalogs as the same user.
+ source, err := querySource("SELECT view_definition FROM information_schema.views WHERE table_schema = " + quoteLiteral(schema) + " AND table_name = " + quoteLiteral(name))
+ if err == nil {
+ return source, nil
+ }
+ if !errors.Is(err, sql.ErrNoRows) {
+ return "", err
+ }
+ }
+
+ catalog, prefix, function := "sys_catalog", "sys", "sys_get_viewdef"
+ if s.mode.postgresCatalog {
+ catalog, prefix, function = "pg_catalog", "pg", "pg_get_viewdef"
+ } else if s.usePgViewDefinition {
+ function = "pg_get_viewdef"
+ }
+ queryCatalog := func(definitionFunction string) (string, error) {
+ query := fmt.Sprintf("SELECT %s(c.oid) FROM %s.%s_class c JOIN %s.%s_namespace n ON n.oid=c.relnamespace WHERE n.nspname=%s AND c.relname=%s AND c.relkind = 'v' LIMIT 1", definitionFunction, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(name))
+ return querySource(query)
+ }
+ source, err := queryCatalog(function)
+ if err == nil {
+ return source, nil
+ }
+ if function == "sys_get_viewdef" {
+ if isUndefinedFunction(err, function) {
+ s.usePgViewDefinition = true
+ } else if !errors.Is(err, sql.ErrNoRows) {
+ return "", err
+ }
+ source, err = queryCatalog("pg_get_viewdef")
+ if err == nil {
+ return source, nil
+ }
+ }
+ if errors.Is(err, sql.ErrNoRows) {
+ return "", fmt.Errorf("view %q.%q does not exist or its source definition is unavailable to the current user", schema, name)
+ }
+ return "", err
+}
+
func (s *server) getMaterializedViewSource(schema, name string) (string, error) {
catalog, prefix, function := "sys_catalog", "sys", "sys_get_viewdef"
if s.mode.postgresCatalog {
diff --git a/agents/drivers/kingbase-go/view_source_integration_test.go b/agents/drivers/kingbase-go/view_source_integration_test.go
new file mode 100644
index 0000000000..9c58a68178
--- /dev/null
+++ b/agents/drivers/kingbase-go/view_source_integration_test.go
@@ -0,0 +1,103 @@
+package main
+
+import (
+ "database/sql"
+ "fmt"
+ "os"
+ "strconv"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestKingbaseNonOwnerViewSourceIntegration(t *testing.T) {
+ host := os.Getenv("KINGBASE_TEST_HOST")
+ portText := os.Getenv("KINGBASE_TEST_PORT")
+ username := os.Getenv("KINGBASE_TEST_USERNAME")
+ if host == "" || portText == "" || username == "" {
+ t.Skip("Kingbase integration environment is not configured")
+ }
+ port, err := strconv.Atoi(portText)
+ if err != nil {
+ t.Fatal(err)
+ }
+ database := os.Getenv("KINGBASE_TEST_DATABASE")
+ if database == "" {
+ database = "test"
+ }
+ cp := connectParams{Host: host, Port: port, Database: database, Username: username, Password: os.Getenv("KINGBASE_TEST_PASSWORD")}
+ if strings.HasPrefix(host, "/") {
+ cp.URLParams = "sslmode=disable"
+ }
+ server := newServer()
+ if err := server.connect(cp); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = server.disconnect() })
+ // SET ROLE and metadata queries must share the connection for the whole test.
+ server.db.SetConnMaxLifetime(0)
+ rolesCatalog := "sys_catalog.sys_roles"
+ if server.mode.postgresCatalog {
+ rolesCatalog = "pg_catalog.pg_roles"
+ }
+ var superuser bool
+ if err := server.requireDBQueryRow("SELECT rolsuper FROM "+rolesCatalog+" WHERE rolname = current_user", &superuser); err != nil {
+ t.Fatal(err)
+ }
+ if !superuser {
+ t.Skip("non-owner view source integration requires a superuser to create and assume an isolated test role")
+ }
+
+ suffix := strconv.FormatInt(time.Now().UnixNano(), 36)
+ schema := "dbx_view_src_" + suffix
+ role := "dbx_view_reader_" + suffix
+ view := "visible_view"
+ qualifiedView := quoteIdentifier(schema) + "." + quoteIdentifier(view)
+ mustExecute(t, server, "CREATE ROLE "+quoteIdentifier(role)+" NOLOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT")
+ t.Cleanup(func() {
+ for _, statement := range []string{
+ "RESET ROLE",
+ "DROP VIEW IF EXISTS " + qualifiedView,
+ "DROP SCHEMA IF EXISTS " + quoteIdentifier(schema),
+ "DROP ROLE IF EXISTS " + quoteIdentifier(role),
+ } {
+ if _, err := server.executeQuery(queryOptions{SQL: statement}); err != nil {
+ t.Errorf("cleanup %s: %v", statement, err)
+ }
+ }
+ })
+ mustExecute(t, server, "CREATE SCHEMA "+quoteIdentifier(schema))
+ mustExecute(t, server, "CREATE VIEW "+qualifiedView+" AS SELECT 13002 AS issue_no")
+ mustExecute(t, server, "GRANT USAGE ON SCHEMA "+quoteIdentifier(schema)+" TO "+quoteIdentifier(role))
+ mustExecute(t, server, "GRANT SELECT ON "+qualifiedView+" TO "+quoteIdentifier(role))
+
+ ownerSource, err := server.getObjectSource(schema, view, "VIEW")
+ if err != nil || !strings.Contains(fmt.Sprint(ownerSource["source"]), "13002") {
+ t.Fatalf("owner could not read view source: source=%v err=%v", ownerSource, err)
+ }
+ mustExecute(t, server, "SET ROLE "+quoteIdentifier(role))
+ var currentUser string
+ if err := server.requireDBQueryRow("SELECT current_user", &currentUser); err != nil || currentUser != role {
+ t.Fatalf("test role was not applied: current_user=%q err=%v", currentUser, err)
+ }
+ var value int
+ if err := server.requireDBQueryRow("SELECT issue_no FROM "+qualifiedView, &value); err != nil || value != 13002 {
+ t.Fatalf("non-owner cannot select from test view: value=%d err=%v", value, err)
+ }
+ if server.mode.mysqlCompat {
+ var definition sql.NullString
+ query := "SELECT view_definition FROM information_schema.views WHERE table_schema = " + quoteLiteral(schema) + " AND table_name = " + quoteLiteral(view)
+ if err := server.requireDBQueryRow(query, &definition); err != nil {
+ t.Fatal(err)
+ }
+ if definition.Valid {
+ t.Fatal("expected a hidden information_schema definition for the non-owner role")
+ }
+ t.Log("non-owner can SELECT the view while information_schema.view_definition is NULL")
+ }
+ source, err := server.getObjectSource(schema, view, "VIEW")
+ if err != nil || !strings.Contains(fmt.Sprint(source["source"]), "13002") {
+ t.Fatalf("non-owner could not read view source: source=%v err=%v", source, err)
+ }
+ t.Logf("non-owner view source recovered (mysqlCompat=%v, postgresCatalog=%v)", server.mode.mysqlCompat, server.mode.postgresCatalog)
+}
diff --git a/agents/drivers/kingbase-go/view_source_test.go b/agents/drivers/kingbase-go/view_source_test.go
new file mode 100644
index 0000000000..30ae679fa9
--- /dev/null
+++ b/agents/drivers/kingbase-go/view_source_test.go
@@ -0,0 +1,230 @@
+package main
+
+import (
+ "database/sql/driver"
+ "errors"
+ "strings"
+ "testing"
+
+ "gitea.com/kingbase/gokb"
+)
+
+func TestOrdinaryViewSourceFallsBackFromHiddenInformationSchemaDefinition(t *testing.T) {
+ for _, test := range []struct {
+ name string
+ rows [][]driver.Value
+ }{
+ {name: "NULL", rows: [][]driver.Value{{nil}}},
+ {name: "empty", rows: [][]driver.Value{{""}}},
+ {name: "whitespace", rows: [][]driver.Value{{" \t\n"}}},
+ {name: "no rows"},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ const definition = " SELECT 'kept verbatim' AS value;\n"
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if strings.Contains(query, "information_schema.views") {
+ if !strings.Contains(query, "table_schema = 'app''s'") || !strings.Contains(query, "table_name = 'View''s'") {
+ return nil, errors.New("information schema query lost its quoted object identity: " + query)
+ }
+ return &valueRows{columns: []string{"view_definition"}, rows: test.rows}, nil
+ }
+ for _, fragment := range []string{"SELECT sys_get_viewdef(c.oid)", "FROM sys_catalog.sys_class", "n.nspname='app''s'", "c.relname='View''s'", "c.relkind = 'v'"} {
+ if !strings.Contains(query, fragment) {
+ return nil, errors.New("fallback query lost its catalog or object identity: " + query)
+ }
+ }
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{definition}}}, nil
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+ server.mode.mysqlCompat = true
+
+ source, err := server.getObjectSource("app's", "View's", "VIEW")
+ if err != nil || source["source"] != definition || source["schema"] != "app's" || source["name"] != "View's" {
+ t.Fatalf("non-owner view definition was not recovered: source=%#v err=%v", source, err)
+ }
+ if queries := state.snapshotQueries(); len(queries) != 2 {
+ t.Fatalf("expected one information schema query and one catalog fallback: %v", queries)
+ }
+ if server.usePgViewDefinition {
+ t.Fatal("an object-specific missing definition must not change the function capability cache")
+ }
+ })
+ }
+}
+
+func TestOrdinaryViewSourceUsesPostgresCatalog(t *testing.T) {
+ for _, mysqlCompat := range []bool{false, true} {
+ t.Run(map[bool]string{false: "direct", true: "information schema fallback"}[mysqlCompat], func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if mysqlCompat && strings.Contains(query, "information_schema.views") {
+ return &valueRows{columns: []string{"view_definition"}, rows: [][]driver.Value{{nil}}}, nil
+ }
+ for _, fragment := range []string{"SELECT pg_get_viewdef(c.oid)", "FROM pg_catalog.pg_class", "pg_catalog.pg_namespace", "n.nspname='app'", "c.relname='orders'", "c.relkind = 'v'"} {
+ if !strings.Contains(query, fragment) {
+ return nil, errors.New("unexpected PostgreSQL catalog query: " + query)
+ }
+ }
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 1 AS order_id"}}}, nil
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+ server.mode.mysqlCompat = mysqlCompat
+ server.mode.postgresCatalog = true
+
+ source, err := server.getObjectSource("app", "orders", "VIEW")
+ if err != nil || source["source"] != "SELECT 1 AS order_id" {
+ t.Fatalf("unexpected PostgreSQL catalog source: source=%#v err=%v", source, err)
+ }
+ wantQueries := 1
+ if mysqlCompat {
+ wantQueries++
+ }
+ if queries := state.snapshotQueries(); len(queries) != wantQueries {
+ t.Fatalf("unexpected catalog probes: %v", queries)
+ }
+ })
+ }
+}
+
+func TestOrdinaryViewSourceCachesUndefinedSysFunction(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ switch {
+ case strings.Contains(query, "information_schema.views"):
+ return &valueRows{columns: []string{"view_definition"}, rows: [][]driver.Value{{nil}}}, nil
+ case strings.Contains(query, "sys_get_viewdef("):
+ return nil, &gokb.Error{Code: gokb.ErrorCode("42883"), Message: "function sys_get_viewdef(oid) does not exist"}
+ case strings.Contains(query, "pg_get_viewdef("):
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 1"}}}, nil
+ default:
+ return nil, errors.New("unexpected query: " + query)
+ }
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+ server.mode.mysqlCompat = true
+
+ for _, name := range []string{"first_view", "second_view"} {
+ source, err := server.getObjectSource("app", name, "VIEW")
+ if err != nil || source["source"] != "SELECT 1" {
+ t.Fatalf("view %s failed: source=%#v err=%v", name, source, err)
+ }
+ }
+ queries := state.snapshotQueries()
+ if !server.usePgViewDefinition || len(queries) != 5 || !strings.Contains(queries[1], "sys_get_viewdef(") || !strings.Contains(queries[2], "pg_get_viewdef(") || !strings.Contains(queries[4], "pg_get_viewdef(") {
+ t.Fatalf("missing sys function was not cached correctly: cached=%v queries=%v", server.usePgViewDefinition, queries)
+ }
+}
+
+func TestOrdinaryViewSourceEmptySysDefinitionDoesNotPoisonCache(t *testing.T) {
+ for _, test := range []struct {
+ name string
+ rows [][]driver.Value
+ }{
+ {name: "NULL", rows: [][]driver.Value{{nil}}},
+ {name: "whitespace", rows: [][]driver.Value{{" \t"}}},
+ {name: "no rows"},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ switch {
+ case strings.Contains(query, "sys_get_viewdef(") && strings.Contains(query, "c.relname='first_view'"):
+ return &valueRows{columns: []string{"source"}, rows: test.rows}, nil
+ case strings.Contains(query, "sys_get_viewdef(") && strings.Contains(query, "c.relname='second_view'"):
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 'sys'"}}}, nil
+ case strings.Contains(query, "pg_get_viewdef("):
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 'pg'"}}}, nil
+ default:
+ return nil, errors.New("unexpected query: " + query)
+ }
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+
+ for _, testView := range []struct{ name, source string }{{"first_view", "SELECT 'pg'"}, {"second_view", "SELECT 'sys'"}} {
+ source, err := server.getObjectSource("app", testView.name, "VIEW")
+ if err != nil || source["source"] != testView.source {
+ t.Fatalf("view-specific fallback failed: source=%#v err=%v", source, err)
+ }
+ }
+ if queries := state.snapshotQueries(); len(queries) != 3 || server.usePgViewDefinition {
+ t.Fatalf("object-specific empty definition poisoned the cache: cached=%v queries=%v", server.usePgViewDefinition, queries)
+ }
+ })
+ }
+}
+
+func TestOrdinaryViewSourceRejectsUnavailableDefinition(t *testing.T) {
+ for _, mode := range []struct {
+ name string
+ mysql, postgres bool
+ wantQueries int
+ }{
+ {name: "mysql", mysql: true, wantQueries: 3},
+ {name: "sys", wantQueries: 2},
+ {name: "postgres", postgres: true, wantQueries: 1},
+ } {
+ for _, empty := range []struct {
+ name string
+ rows [][]driver.Value
+ }{
+ {name: "NULL", rows: [][]driver.Value{{nil}}},
+ {name: "blank", rows: [][]driver.Value{{" \n"}}},
+ {name: "no rows"},
+ } {
+ t.Run(mode.name+"/"+empty.name, func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ return &valueRows{columns: []string{"view_definition"}, rows: empty.rows}, nil
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+ server.mode.mysqlCompat = mode.mysql
+ server.mode.postgresCatalog = mode.postgres
+
+ _, err := server.getObjectSource("app", "unavailable_view", "VIEW")
+ if err == nil || !strings.Contains(err.Error(), "view") || !strings.Contains(err.Error(), "source") || strings.Contains(err.Error(), "Scan error") {
+ t.Fatalf("expected an explicit unavailable view source error, got %v", err)
+ }
+ if queries := state.snapshotQueries(); len(queries) != mode.wantQueries || server.usePgViewDefinition {
+ t.Fatalf("unbounded probes or invalid capability cache: cached=%v queries=%v", server.usePgViewDefinition, queries)
+ }
+ })
+ }
+ }
+}
+
+func TestOrdinaryViewSourcePreservesQueryErrors(t *testing.T) {
+ for _, stage := range []struct {
+ name string
+ wantQueries int
+ }{
+ {name: "information_schema.views", wantQueries: 1},
+ {name: "sys_get_viewdef(", wantQueries: 2},
+ {name: "pg_get_viewdef(", wantQueries: 3},
+ } {
+ for _, queryErr := range []error{
+ &gokb.Error{Code: gokb.ErrorCode("42501"), Message: "permission denied"},
+ errors.New("connection reset by peer"),
+ } {
+ t.Run(stage.name+"/"+queryErr.Error(), func(t *testing.T) {
+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {
+ if strings.Contains(query, stage.name) {
+ return nil, queryErr
+ }
+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{nil}}}, nil
+ }}
+ server := newServer()
+ server.db = openMetadataDB(t, state)
+ server.mode.mysqlCompat = true
+
+ _, err := server.getObjectSource("app", "orders", "VIEW")
+ if !errors.Is(err, queryErr) {
+ t.Fatalf("query error was swallowed or replaced: want=%v got=%v", queryErr, err)
+ }
+ if queries := state.snapshotQueries(); len(queries) != stage.wantQueries || server.usePgViewDefinition {
+ t.Fatalf("unrelated error triggered fallback or poisoned cache: cached=%v queries=%v", server.usePgViewDefinition, queries)
+ }
+ })
+ }
+ }
+}