From 21ef506fc995259e48680477ce8eb06556bbd957 Mon Sep 17 00:00:00 2001 From: AndyZhang Date: Mon, 12 Oct 2026 11:26:34 +0800 Subject: [PATCH] fix(agent): scope database queries to authorized shared knowledge bases (#4136) Resolve database query tenant scopes for authorized shared knowledge bases and add regression coverage for cross-tenant access. Fixes Tencent/WeKnora#4084 --- internal/agent/tools/database_query.go | 1 + internal/agent/tools/database_query_test.go | 73 +++++++ internal/utils/inject.go | 76 +++++--- internal/utils/inject_shared_tenant_test.go | 205 ++++++++++++++++++++ 4 files changed, 332 insertions(+), 23 deletions(-) create mode 100644 internal/utils/inject_shared_tenant_test.go diff --git a/internal/agent/tools/database_query.go b/internal/agent/tools/database_query.go index 20bda0b7..2d2de148 100644 --- a/internal/agent/tools/database_query.go +++ b/internal/agent/tools/database_query.go @@ -290,6 +290,7 @@ func searchScopesFromTargets(searchTargets types.SearchTargets) []utils.SearchSc } scopes = append(scopes, utils.SearchScope{ KnowledgeBaseID: target.KnowledgeBaseID, + TenantID: target.TenantID, KnowledgeIDs: knowledgeIDs, TagIDs: tagIDs, }) diff --git a/internal/agent/tools/database_query_test.go b/internal/agent/tools/database_query_test.go index ab389ed1..5678156f 100644 --- a/internal/agent/tools/database_query_test.go +++ b/internal/agent/tools/database_query_test.go @@ -1,9 +1,12 @@ package tools import ( + "database/sql" "strings" "testing" + _ "github.com/mattn/go-sqlite3" + "github.com/Tencent/WeKnora/internal/types" ) @@ -24,3 +27,73 @@ func TestDatabaseQueryInjectsEnabledChunkFilter(t *testing.T) { t.Fatalf("Agent SQL must exclude disabled chunks:\n%s", securedSQL) } } + +// Execute the secured SQL against synthetic rows so the test checks access, +// rather than just the spelling of an injected predicate. +func TestDatabaseQuerySharedTenantScope(t *testing.T) { + db, err := sql.Open("sqlite3", ":memory:") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = db.Close() }) + db.SetMaxOpenConns(1) + _, err = db.Exec(` + CREATE TABLE chunks (id TEXT, tenant_id INTEGER, knowledge_base_id TEXT, + knowledge_id TEXT, is_enabled BOOLEAN, deleted_at TEXT); + INSERT INTO chunks VALUES + ('shared', 2, 'shared-kb', 'shared-doc', true, NULL), + ('own', 1, 'own-kb', 'own-doc', true, NULL), + ('unshared', 2, 'private-kb', 'private-doc', true, NULL), + ('wrong-owner', 3, 'shared-kb', 'shared-doc', true, NULL), + ('swapped-owner', 2, 'own-kb', 'own-doc', true, NULL), + ('disabled', 2, 'shared-kb', 'shared-doc', false, NULL), + ('deleted', 2, 'shared-kb', 'shared-doc', true, '2026-01-01');`) + if err != nil { + t.Fatal(err) + } + tool := NewDatabaseQueryTool(nil, types.SearchTargets{ + {Type: types.SearchTargetTypeKnowledgeBase, KnowledgeBaseID: "shared-kb", TenantID: 2}, + {Type: types.SearchTargetTypeKnowledgeBase, KnowledgeBaseID: "own-kb", TenantID: 1}, + }) + secured, err := tool.validateAndSecureSQL("SELECT c.id FROM chunks c ORDER BY c.id", 1) + if err != nil { + t.Fatal(err) + } + rows, err := db.Query(secured) + if err != nil { + t.Fatalf("query %s: %v", secured, err) + } + defer func() { _ = rows.Close() }() + var got []string + for rows.Next() { + var id string + if err := rows.Scan(&id); err != nil { + t.Fatal(err) + } + got = append(got, id) + } + if err := rows.Err(); err != nil { + t.Fatal(err) + } + if strings.Join(got, ",") != "own,shared" { + t.Fatalf("authorized own and shared rows = %v, want [own shared]; SQL: %s", got, secured) + } +} + +func TestDatabaseQueryRejectsEmptyScope(t *testing.T) { + for name, targets := range map[string]types.SearchTargets{ + "nil": nil, + "empty": {}, + "nil target": {nil}, + "empty KB": {{Type: types.SearchTargetTypeKnowledgeBase, TenantID: 2}}, + "empty document scope": {{Type: types.SearchTargetTypeKnowledge, KnowledgeBaseID: "shared-kb", TenantID: 2}}, + } { + t.Run(name, func(t *testing.T) { + tool := NewDatabaseQueryTool(nil, targets) + secured, err := tool.validateAndSecureSQL("SELECT id FROM chunks", 1) + if err == nil || secured != "" { + t.Fatalf("empty scope produced executable SQL %q, error %v", secured, err) + } + }) + } +} diff --git a/internal/utils/inject.go b/internal/utils/inject.go index 6e67b5fb..9dae18fd 100644 --- a/internal/utils/inject.go +++ b/internal/utils/inject.go @@ -154,6 +154,9 @@ type sqlValidator struct { // SearchScope describes one allowed knowledge scope for SQL query injection. // Empty KnowledgeIDs and TagIDs means the whole KB is in scope. type SearchScope struct { + // TenantID is the authorized owner of this KB. Zero uses the caller tenant + // when tenant isolation is enabled. Scopes must be authorized by the caller. + TenantID uint64 KnowledgeBaseID string KnowledgeIDs []string TagIDs []string @@ -653,7 +656,9 @@ func WithSearchScopeFilter(kbIDs []string, knowledgeIDs []string) SQLValidationO } // WithSearchScopes restricts queries using structured OR scopes. Each scope can -// represent a full KB, specific documents, or a tag-constrained KB. +// represent a full KB, specific documents, or a tag-constrained KB. Nonzero +// TenantID values grant access to that owner within that scope, so scopes must +// come from server-side authorization, never directly from untrusted input. func WithSearchScopes(scopes []SearchScope) SQLValidationOption { return func(v *sqlValidator) { if len(scopes) == 0 { @@ -1059,6 +1064,12 @@ func (v *sqlValidator) injectTenantConditions(sql string, tablesInQuery map[stri var conditions []string for tableName, alias := range tablesInQuery { if v.tablesWithTenantID[tableName] { + // Structured scopes bind each owner to its own KB and document/tag + // restrictions below. A global caller filter would reject shared KBs. + if v.enableSearchScopeFilter && len(v.searchScopes) > 0 && + (tableName == "knowledge_bases" || tableName == "knowledges" || tableName == "chunks") { + continue + } if tableName == "tenants" { conditions = append(conditions, fmt.Sprintf("%s.id = %d", alias, v.tenantID)) } else { @@ -1168,17 +1179,17 @@ func (v *sqlValidator) injectStructuredSearchScopeConditions(sql string, tablesI var conditions []string if alias, ok := tablesInQuery["knowledge_bases"]; ok { - if cond := buildKnowledgeBaseScopeCondition(alias, v.searchScopes); cond != "" { + if cond := v.buildKnowledgeBaseScopeCondition(alias, v.searchScopes); cond != "" { conditions = append(conditions, cond) } } if alias, ok := tablesInQuery["knowledges"]; ok { - if cond := buildKnowledgeScopeCondition(alias, v.searchScopes); cond != "" { + if cond := v.buildKnowledgeScopeCondition(alias, v.searchScopes); cond != "" { conditions = append(conditions, cond) } } if alias, ok := tablesInQuery["chunks"]; ok { - if cond := buildChunkScopeCondition(alias, v.searchScopes); cond != "" { + if cond := v.buildChunkScopeCondition(alias, v.searchScopes); cond != "" { conditions = append(conditions, cond) } } @@ -1189,19 +1200,29 @@ func (v *sqlValidator) injectStructuredSearchScopeConditions(sql string, tablesI return InjectAndConditions(sql, strings.Join(conditions, " AND ")) } -func buildKnowledgeBaseScopeCondition(alias string, scopes []SearchScope) string { - kbIDs := uniqueScopeKBIDs(scopes) - if len(kbIDs) == 0 { - return "" +func (v *sqlValidator) buildKnowledgeBaseScopeCondition(alias string, scopes []SearchScope) string { + clauses := make([]string, 0, len(scopes)) + for _, scope := range scopes { + if scope.KnowledgeBaseID == "" { + continue + } + clause := fmt.Sprintf("%s.id = %s", alias, quoteString(scope.KnowledgeBaseID)) + if tenant := v.scopeTenantCondition(alias, scope); tenant != "" { + clause = "(" + clause + " AND " + tenant + ")" + } + clauses = append(clauses, clause) } - return fmt.Sprintf("%s.id IN (%s)", alias, strings.Join(quoteStringSlice(kbIDs), ", ")) + if len(clauses) == 0 { + return "false" + } + return joinOrClauses(clauses) } // buildScopeClause renders one scope. A scope's document whitelist and tag // filter are ANDed: each is an independent narrowing of the same KB, so // applying only one of them would admit rows the other excludes. Scopes are // ORed against each other by joinOrClauses because they are alternatives. -func buildScopeClause(alias, knowledgeIDColumn string, scope SearchScope) string { +func (v *sqlValidator) buildScopeClause(alias, knowledgeIDColumn string, scope SearchScope) string { if scope.KnowledgeBaseID == "" { return "" } @@ -1220,43 +1241,52 @@ func buildScopeClause(alias, knowledgeIDColumn string, scope SearchScope) string alias, knowledgeIDColumn, strings.Join(quoteStringSlice(scope.TagIDs), ", "), )) } + if tenant := v.scopeTenantCondition(alias, scope); tenant != "" { + conditions = append(conditions, tenant) + } if len(conditions) == 1 { return conditions[0] } return "(" + strings.Join(conditions, " AND ") + ")" } -func buildKnowledgeScopeCondition(alias string, scopes []SearchScope) string { +func (v *sqlValidator) buildKnowledgeScopeCondition(alias string, scopes []SearchScope) string { clauses := make([]string, 0, len(scopes)) for _, scope := range scopes { - if clause := buildScopeClause(alias, "id", scope); clause != "" { + if clause := v.buildScopeClause(alias, "id", scope); clause != "" { clauses = append(clauses, clause) } } + if len(clauses) == 0 { + return "false" + } return joinOrClauses(clauses) } -func buildChunkScopeCondition(alias string, scopes []SearchScope) string { +func (v *sqlValidator) buildChunkScopeCondition(alias string, scopes []SearchScope) string { clauses := make([]string, 0, len(scopes)) for _, scope := range scopes { - if clause := buildScopeClause(alias, "knowledge_id", scope); clause != "" { + if clause := v.buildScopeClause(alias, "knowledge_id", scope); clause != "" { clauses = append(clauses, clause) } } + if len(clauses) == 0 { + return "false" + } return joinOrClauses(clauses) } -func uniqueScopeKBIDs(scopes []SearchScope) []string { - seen := make(map[string]bool, len(scopes)) - out := make([]string, 0, len(scopes)) - for _, scope := range scopes { - if scope.KnowledgeBaseID == "" || seen[scope.KnowledgeBaseID] { - continue +// scopeTenantCondition keeps ownership in the same OR branch as the KB and +// document/tag restrictions. Missing ownership retains caller-only isolation. +func (v *sqlValidator) scopeTenantCondition(alias string, scope SearchScope) string { + tenantID := scope.TenantID + if tenantID == 0 { + if !v.enableTenantInjection { + return "" } - seen[scope.KnowledgeBaseID] = true - out = append(out, scope.KnowledgeBaseID) + tenantID = v.tenantID } - return out + return fmt.Sprintf("%s.tenant_id = %d", alias, tenantID) } func joinOrClauses(clauses []string) string { diff --git a/internal/utils/inject_shared_tenant_test.go b/internal/utils/inject_shared_tenant_test.go new file mode 100644 index 00000000..8fb03c05 --- /dev/null +++ b/internal/utils/inject_shared_tenant_test.go @@ -0,0 +1,205 @@ +package utils + +import ( + "database/sql" + "reflect" + "strings" + "testing" + + _ "github.com/mattn/go-sqlite3" +) + +func sharedTenantFixture(t *testing.T) *sql.DB { + t.Helper() + db, err := sql.Open("sqlite3", ":memory:") + if err != nil { + t.Fatal(err) + } + db.SetMaxOpenConns(1) + t.Cleanup(func() { _ = db.Close() }) + _, err = db.Exec(` +CREATE TABLE knowledge_bases (id TEXT, tenant_id INTEGER, name TEXT); +CREATE TABLE knowledges (id TEXT, tenant_id INTEGER, knowledge_base_id TEXT, title TEXT); +CREATE TABLE chunks (id TEXT, tenant_id INTEGER, knowledge_base_id TEXT, knowledge_id TEXT); +CREATE TABLE knowledge_tag_relations (knowledge_id TEXT, tag_id TEXT); +CREATE TABLE sessions (id TEXT, tenant_id INTEGER); +CREATE TABLE tenants (id INTEGER, name TEXT); +INSERT INTO knowledge_bases VALUES + ('own-kb', 1, 'own'), ('shared-kb', 2, 'shared'), + ('private-kb', 2, 'private'), ('shared-kb', 1, 'wrong-owner'), + ('own-kb', 2, 'swapped-owner'); +INSERT INTO knowledges VALUES + ('own-doc', 1, 'own-kb', 'own'), ('shared-doc', 2, 'shared-kb', 'shared'), + ('private-doc', 2, 'private-kb', 'private'), + ('shared-doc', 1, 'shared-kb', 'wrong-owner'), + ('own-doc', 2, 'own-kb', 'swapped-owner'), + ('other-doc', 2, 'shared-kb', 'outside-document'), + ('untagged-doc', 2, 'shared-kb', 'outside-tag'); +INSERT INTO chunks VALUES + ('own', 1, 'own-kb', 'own-doc'), ('shared', 2, 'shared-kb', 'shared-doc'), + ('private', 2, 'private-kb', 'private-doc'), + ('wrong-owner', 1, 'shared-kb', 'shared-doc'), + ('swapped-owner', 2, 'own-kb', 'own-doc'), + ('outside-document', 2, 'shared-kb', 'other-doc'), + ('outside-tag', 2, 'shared-kb', 'untagged-doc'); +INSERT INTO knowledge_tag_relations VALUES + ('own-doc', 'own-tag'), ('shared-doc', 'shared-tag'), ('other-doc', 'shared-tag'); +INSERT INTO sessions VALUES ('own-session', 1), ('other-session', 2); +INSERT INTO tenants VALUES (1, 'own-tenant'), (2, 'other-tenant');`) + if err != nil { + t.Fatal(err) + } + return db +} + +func assertSharedTenantQuery(t *testing.T, db *sql.DB, query string, want []string, opts ...SQLValidationOption) { + t.Helper() + secured, validation, err := ValidateAndSecureSQL(query, opts...) + if err != nil || !validation.Valid { + t.Fatalf("secure query %q: validation=%+v, err=%v", query, validation, err) + } + rows, err := db.Query(secured) + if err != nil { + t.Fatalf("execute secured SQL %s: %v", secured, err) + } + defer func() { _ = rows.Close() }() + var got []string + for rows.Next() { + var value string + if err := rows.Scan(&value); err != nil { + t.Fatal(err) + } + got = append(got, value) + } + if err := rows.Err(); err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(got, want) { + t.Fatalf("results = %v, want %v; secured SQL: %s", got, want, secured) + } +} + +func TestStructuredScopeTenantPairing(t *testing.T) { + db := sharedTenantFixture(t) + scopes := []SearchScope{ + {TenantID: 1, KnowledgeBaseID: "own-kb", KnowledgeIDs: []string{"own-doc"}, TagIDs: []string{"own-tag"}}, + { + TenantID: 2, KnowledgeBaseID: "shared-kb", + KnowledgeIDs: []string{"shared-doc", "untagged-doc"}, TagIDs: []string{"shared-tag"}, + }, + } + for _, query := range []string{ + "SELECT name FROM knowledge_bases ORDER BY name", + "SELECT k.title FROM knowledges k ORDER BY k.title", + "SELECT c.id FROM chunks c ORDER BY c.id", + `SELECT "Shared Rows".id FROM chunks "Shared Rows" ORDER BY "Shared Rows".id`, + "SELECT c.id FROM chunks c JOIN knowledges k ON k.id = c.knowledge_id ORDER BY c.id", + "SELECT c.id FROM chunks c JOIN chunks d ON c.knowledge_id = d.knowledge_id ORDER BY c.id", + "SELECT c.id FROM chunks c JOIN knowledge_bases kb ON kb.id = c.knowledge_base_id ORDER BY c.id", + "SELECT c.id FROM chunks c WHERE c.id IN (SELECT c.id FROM chunks c) ORDER BY c.id", + } { + t.Run(query, func(t *testing.T) { + assertSharedTenantQuery(t, db, query, []string{"own", "shared"}, + WithTenantIsolation(1), WithSearchScopes(scopes)) + }) + } +} + +func TestStructuredScopeTenantTagOnly(t *testing.T) { + db := sharedTenantFixture(t) + assertSharedTenantQuery(t, db, "SELECT c.id FROM chunks c ORDER BY c.id", []string{"outside-document", "shared"}, + WithTenantIsolation(1), WithSearchScopes([]SearchScope{ + {TenantID: 2, KnowledgeBaseID: "shared-kb", TagIDs: []string{"shared-tag"}}, + })) +} + +func TestStructuredScopeTenantZeroFallback(t *testing.T) { + db := sharedTenantFixture(t) + for _, query := range []string{ + "SELECT name FROM knowledge_bases ORDER BY name", + "SELECT title FROM knowledges ORDER BY title", + "SELECT id FROM chunks ORDER BY id", + } { + t.Run(query, func(t *testing.T) { + assertSharedTenantQuery(t, db, query, []string{"own"}, + WithTenantIsolation(1), WithSearchScopes([]SearchScope{ + {KnowledgeBaseID: "own-kb"}, + })) + }) + } +} + +func TestStructuredScopeInvalidTenantScopesFailClosed(t *testing.T) { + db := sharedTenantFixture(t) + for _, table := range []string{"knowledge_bases", "knowledges", "chunks"} { + t.Run(table, func(t *testing.T) { + assertSharedTenantQuery(t, db, "SELECT id FROM "+table, nil, + WithTenantIsolation(1), WithSearchScopes([]SearchScope{{TenantID: 2}, {}})) + }) + } + // Invalid alternatives must not turn an OR restriction into unrestricted access. + assertSharedTenantQuery(t, db, "SELECT id FROM chunks ORDER BY id", []string{"own"}, + WithTenantIsolation(1), WithSearchScopes([]SearchScope{ + {TenantID: 2}, {TenantID: 1, KnowledgeBaseID: "own-kb"}, + })) +} + +func TestStructuredScopePreservesOtherTenantTables(t *testing.T) { + db := sharedTenantFixture(t) + opts := []SQLValidationOption{ + WithTenantIsolation(1, "chunks", "sessions", "tenants"), + WithSearchScopes([]SearchScope{ + {TenantID: 2, KnowledgeBaseID: "shared-kb", KnowledgeIDs: []string{"shared-doc"}}, + }), + } + assertSharedTenantQuery(t, db, "SELECT id FROM sessions ORDER BY id", []string{"own-session"}, opts...) + assertSharedTenantQuery(t, db, "SELECT name FROM tenants ORDER BY name", []string{"own-tenant"}, opts...) + assertSharedTenantQuery(t, db, "SELECT c.id || ':' || s.id FROM chunks c CROSS JOIN sessions s", + []string{"shared:own-session"}, opts...) +} + +func TestStructuredScopePreservesLegacyTenantFiltering(t *testing.T) { + db := sharedTenantFixture(t) + assertSharedTenantQuery(t, db, "SELECT id FROM chunks ORDER BY id", []string{"own", "wrong-owner"}, + WithTenantIsolation(1), WithSearchScopeFilter([]string{"own-kb", "shared-kb"}, nil)) + assertSharedTenantQuery(t, db, "SELECT id FROM chunks ORDER BY id", []string{"own", "wrong-owner"}, + WithTenantIsolation(1), WithSearchScopes(nil)) + // A zero-tenant scope without tenant injection retains its original optional semantics. + assertSharedTenantQuery(t, db, "SELECT id FROM chunks ORDER BY id", []string{"own", "swapped-owner"}, + WithSearchScopes([]SearchScope{{KnowledgeBaseID: "own-kb"}})) + secured, _, err := ValidateAndSecureSQL("SELECT id FROM chunks", + WithSearchScopes([]SearchScope{{KnowledgeBaseID: "own-kb"}})) + if err != nil || strings.Contains(secured, "tenant_id") { + t.Fatalf("optional scope unexpectedly injected tenant filter: %s; error=%v", secured, err) + } +} + +// The owner/KB predicate must remain bound to the outer table when a +// user-chosen alias also occurs inside an injected subquery. +func TestStructuredScopeTagAliasRetainsTenantBinding(t *testing.T) { + db := sharedTenantFixture(t) + assertSharedTenantQuery(t, db, + "SELECT ktr.id FROM chunks ktr WHERE ktr.knowledge_id = 'shared-doc' ORDER BY ktr.id", []string{"shared"}, + WithTenantIsolation(1), WithSearchScopes([]SearchScope{ + {TenantID: 2, KnowledgeBaseID: "shared-kb", TagIDs: []string{"shared-tag"}}, + })) +} + +func TestStructuredScopeCallerZeroRemainsRestricted(t *testing.T) { + db := sharedTenantFixture(t) + assertSharedTenantQuery(t, db, "SELECT id FROM chunks ORDER BY id", nil, + WithTenantIsolation(0), WithSearchScopes([]SearchScope{{KnowledgeBaseID: "own-kb"}})) + // Explicitly authorized ownership also constrains a scope used on its own. + assertSharedTenantQuery(t, db, "SELECT id FROM chunks ORDER BY id", []string{"own"}, + WithSearchScopes([]SearchScope{{TenantID: 1, KnowledgeBaseID: "own-kb"}})) +} + +func TestStructuredScopeStillRejectsCompoundQuery(t *testing.T) { + _, validation, err := ValidateAndSecureSQL( + "SELECT id FROM chunks UNION SELECT id FROM chunks ORDER BY id", + WithTenantIsolation(1), WithSearchScopes([]SearchScope{{TenantID: 2, KnowledgeBaseID: "shared-kb"}}), + ) + if err == nil || validation.Valid { + t.Fatal("structured owner scopes must not permit previously rejected compound queries") + } +}