Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(api): clamp memory list tenant_id filter to joined tenants (#19739)

coderdailyone7ebe0d22b730
diff --git a/internal/service/memory.go b/internal/service/memory.go
index 07932b5cf9..cc03263b74 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -1563,18 +1563,39 @@ func (s *MemoryService) requireMemoryAccess(ctx context.Context, userID string,
//
// resp, err := service.ListMemories("user123", []string{}, []string{"semantic"}, "table", "test", 1, 10)
func (s *MemoryService) ListMemories(ctx context.Context, userID string, tenantIDs []string, memoryTypes []string, storageType string, keywords string, page int, pageSize int) (*ListMemoryResponse, error) {
- // If tenantIDs is empty, get all tenants associated with the user
+ // The tenant filter may only name tenants the caller belongs to: Python's
+ // list_memory intersects the requested ids with the caller's joined
+ // tenants and returns an empty page when nothing survives. Without the
+ // clamp a caller could list another tenant's team-shared memories by
+ // passing its id in the tenant_id query parameter.
+ userTenantService := NewUserTenantService()
+ userTenants, err := userTenantService.GetUserTenantRelationByUserIDWithContext(ctx, userID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get user tenants: %w", err)
+ }
+ joinedIDs := make([]string, 0, len(userTenants)+1)
+ joinedIDs = append(joinedIDs, userID)
+ for _, tenant := range userTenants {
+ joinedIDs = append(joinedIDs, tenant.TenantID)
+ }
+
if len(tenantIDs) == 0 {
- userTenantService := NewUserTenantService()
- userTenants, err := userTenantService.GetUserTenantRelationByUserIDWithContext(ctx, userID)
- if err != nil {
- return nil, fmt.Errorf("failed to get user tenants: %w", err)
+ tenantIDs = joinedIDs
+ } else {
+ joined := make(map[string]struct{}, len(joinedIDs))
+ for _, id := range joinedIDs {
+ joined[id] = struct{}{}
+ }
+ allowed := make([]string, 0, len(tenantIDs))
+ for _, id := range tenantIDs {
+ if _, ok := joined[id]; ok {
+ allowed = append(allowed, id)
+ }
}
- tenantIDs = make([]string, 0, len(userTenants)+1)
- tenantIDs = append(tenantIDs, userID)
- for _, tenant := range userTenants {
- tenantIDs = append(tenantIDs, tenant.TenantID)
+ if len(allowed) == 0 {
+ return &ListMemoryResponse{MemoryList: []map[string]interface{}{}}, nil
}
+ tenantIDs = allowed
}
memories, total, err := s.memoryDAO.GetByFilter(ctx, dao.DB, userID, tenantIDs, memoryTypes, storageType, keywords, page, pageSize)
diff --git a/internal/service/memory_message_test.go b/internal/service/memory_message_test.go
index e8b97fa861..8ec361aa33 100644
--- a/internal/service/memory_message_test.go
+++ b/internal/service/memory_message_test.go
@@ -492,6 +492,116 @@ func TestListMemoriesFallsBackToRawModelIDWithoutTenantModelID(t *testing.T) {
}
}
+// A caller may not list memories of a tenant they have not joined, even when
+// the target memories carry the team permission. Python list_memory clamps the
+// requested tenant_id filter to the caller's joined tenants; the Go port
+// passed the requested ids straight through, so ?tenant_id=<foreign> listed
+// that tenant's team-shared memories.
+func TestListMemoriesRejectsUnjoinedTenantFilter(t *testing.T) {
+ setupMemoryMessageTestDB(t)
+
+ for _, u := range []*entity.User{
+ {ID: "user-1", Nickname: "Caller"},
+ {ID: "tenant-2", Nickname: "Foreign owner"},
+ } {
+ if err := dao.DB.Create(u).Error; err != nil {
+ t.Fatalf("seed user: %v", err)
+ }
+ }
+ if err := dao.DB.Create(&entity.Memory{
+ ID: "mem-foreign-team",
+ Name: "Foreign team memory",
+ TenantID: "tenant-2",
+ MemoryType: dao.MemoryTypeRaw,
+ StorageType: "table",
+ EmbdID: "embd",
+ LLMID: "llm",
+ Permissions: string(TenantPermissionTeam),
+ ForgettingPolicy: string(ForgettingPolicyFIFO),
+ }).Error; err != nil {
+ t.Fatalf("seed memory: %v", err)
+ }
+
+ resp, err := NewMemoryService().ListMemories(t.Context(), "user-1", []string{"tenant-2"}, nil, "", "", 1, 10)
+ if err != nil {
+ t.Fatalf("ListMemories: %v", err)
+ }
+ if resp.TotalCount != 0 || len(resp.MemoryList) != 0 {
+ t.Fatalf("foreign tenant filter must return no memories, got total=%d list=%v", resp.TotalCount, resp.MemoryList)
+ }
+}
+
+// A caller who has joined the tenant may still use the tenant_id filter, and a
+// mixed filter keeps only the joined ids.
+func TestListMemoriesKeepsJoinedTenantFilter(t *testing.T) {
+ setupMemoryMessageTestDB(t)
+
+ for _, u := range []*entity.User{
+ {ID: "user-1", Nickname: "Caller"},
+ {ID: "tenant-2", Nickname: "Joined owner"},
+ {ID: "tenant-3", Nickname: "Foreign owner"},
+ } {
+ if err := dao.DB.Create(u).Error; err != nil {
+ t.Fatalf("seed user: %v", err)
+ }
+ }
+ if err := dao.DB.Create(&entity.UserTenant{
+ ID: "ut-user-1-tenant-2",
+ UserID: "user-1",
+ TenantID: "tenant-2",
+ Role: "normal",
+ Status: sptr("1"),
+ }).Error; err != nil {
+ t.Fatalf("seed user_tenant: %v", err)
+ }
+ for _, m := range []*entity.Memory{
+ {
+ ID: "mem-joined-team",
+ Name: "Joined team memory",
+ TenantID: "tenant-2",
+ MemoryType: dao.MemoryTypeRaw,
+ StorageType: "table",
+ EmbdID: "embd",
+ LLMID: "llm",
+ Permissions: string(TenantPermissionTeam),
+ ForgettingPolicy: string(ForgettingPolicyFIFO),
+ },
+ {
+ ID: "mem-foreign-team",
+ Name: "Foreign team memory",
+ TenantID: "tenant-3",
+ MemoryType: dao.MemoryTypeRaw,
+ StorageType: "table",
+ EmbdID: "embd",
+ LLMID: "llm",
+ Permissions: string(TenantPermissionTeam),
+ ForgettingPolicy: string(ForgettingPolicyFIFO),
+ },
+ } {
+ if err := dao.DB.Create(m).Error; err != nil {
+ t.Fatalf("seed memory %s: %v", m.ID, err)
+ }
+ }
+
+ ctx := t.Context()
+
+ resp, err := NewMemoryService().ListMemories(ctx, "user-1", []string{"tenant-2"}, nil, "", "", 1, 10)
+ if err != nil {
+ t.Fatalf("ListMemories: %v", err)
+ }
+ if resp.TotalCount != 1 || len(resp.MemoryList) != 1 || resp.MemoryList[0]["id"] != "mem-joined-team" {
+ t.Fatalf("joined tenant filter must return its team memory, got total=%d list=%v", resp.TotalCount, resp.MemoryList)
+ }
+
+ resp, err = NewMemoryService().ListMemories(ctx, "user-1", []string{"tenant-2", "tenant-3"}, nil, "", "", 1, 10)
+ if err != nil {
+ t.Fatalf("ListMemories: %v", err)
+ }
+ if resp.TotalCount != 1 || len(resp.MemoryList) != 1 || resp.MemoryList[0]["id"] != "mem-joined-team" {
+ t.Fatalf("mixed filter must drop the unjoined tenant, got total=%d list=%v", resp.TotalCount, resp.MemoryList)
+ }
+}
+
func seedMemoryMessages(t *testing.T) {
t.Helper()