Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(agent): scope database queries to authorized shared knowledge bases (#4136)

AndyZhang21ef506fc995
diff --git a/internal/agent/tools/database_query.go b/internal/agent/tools/database_query.go
index 20bda0b78..2d2de1480 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 ab389ed1d..5678156f5 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 6e67b5fbc..9dae18fd8 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)
+ }
+ if len(clauses) == 0 {
+ return "false"
}
- return fmt.Sprintf("%s.id IN (%s)", alias, strings.Join(quoteStringSlice(kbIDs), ", "))
+ 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 000000000..8fb03c055
--- /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")
+ }
+}