WeKnora/internal/handler/initialization_owner_test.go

190 lines
6.5 KiB
Go
Raw Normal View History

fix(security): close cross-workspace access paths in shared spaces (#3408) * fix(security): close cross-workspace access paths in shared spaces A review of how shared-space (organization) members reach each other's resources found six paths that bypass the org-share permission model: - presigned-preview signed any resource handle or storage path, turning a known resource:// handle into an anonymous /r/ URL that outlives share revocation. It now requires the path to belong to the caller's tenant, like /files. - POST /initialization/initialize let a shared-KB editor rewrite the owner workspace's models (base URL, API key) in place. Only the KB's own workspace may call it, and rewriting a stored model needs the same authority as PUT /models/:id. - KB JSON carried the legacy inline credentials (storage_config secret_id/secret_key, which initialization fills with the MinIO env keys, and vlm_config api_key) to every share receiver. They are withheld from JSON; their DB columns are unchanged. - A chat without agent_source_tenant_id resolved shares before the caller's own agent, so a member sharing a same-ID built-in agent took over other workspaces' default agent. Own agents now win, built-in agents can no longer be shared (existing such shares no longer resolve), and embed channels drop a visitor-supplied source workspace. - Any org-admin tenant (even a tenant Viewer inside it) could raise another workspace's KB share to editor/admin, and the route guard was bypassable via an unrelated :id. Share management is now: the sharer from the source tenant (Contributor+), source-tenant Admin+, or an org-admin tenant's Admin+ that may only remove or lower. share_id must belong to :id. - Wiki write tools were registered for every wiki KB in the search targets, which only need read access, so a viewer share (e.g. via the built-in wiki fixer) could edit or delete another workspace's wiki pages. They now act only on KBs the caller may edit. * fix(security): close the KB settings path and owner details for share receivers Follow-up to the shared-space review: - PUT /initialization/config shares the route guard that admits share editors, so an editor could still rebind the owner's KB models, chunking and storage, and storage backends resolved against the caller's workspace let it bind the owner's KB to its own backend. Another workspace now needs an admin share (the only share level the frontend offers settings to) and may not change the storage binding at all. - GET /initialization/config showed model base URLs and bucket locations to any admin of the caller's own workspace, including share receivers. They now only see whether credentials are configured. - Wiki write tools on the caller's own KBs had no role floor, so a tenant Viewer (and the IM, embed and MCP endpoint principals that run as Viewer) could write through an agent what the HTTP routes deny. Writes now need Contributor+, or the ingest capability for a scoped API key, following the RBAC rollout switch. - resolveAgent logs the share lookup error instead of a nil own-agent error when a shared selector fails. * fix(security): close the medium shared-space access findings Follow-up to the high-risk fixes, from the same review: - Wiki fixer moved into a shared KB's workspace ran with the caller's own config there: an unset MCP mode registered all of the owner's MCP services, and an "all" KB scope reached the owner's other KBs. The scoped run now uses the built-in config pinned to that one KB, without MCP, skills, sandbox or web search, and falls back to the KB's own model. - An unset MCP mode means "all" at runtime but is shown as none in the share scope; shared runs now treat it as none. - Quick-answer mode used the request's web_search_enabled alone, so a receiver could turn on search the agent disables and spend the owner's provider quota. It now requires the agent setting too, as agent mode does. - summary_model_id picked any model of the workspace a run executes in. It is ignored for shared agents and the relocated wiki fixer. - A workspace that left or was removed from an organization kept sharing its KBs and agents. Its shares are revoked on departure, and share queries and permission checks require the source workspace's membership and a live organization, which also covers rows left behind earlier. - Sharing an agent exposes its KB scope to all members, so a Contributor could share colleagues' KBs (or "all") through an agent. The sharer must now be able to share each KB directly (creator or Admin+; "all" needs Admin+), also when a shared agent's scope is widened later. - A scoped API key with manage_channels could mint an MCP endpoint token wider than itself. Endpoints it creates, updates or rotates must stay within its KB allow-list and capabilities. - A shared agent's run indexed the receiver's Q&A into the owner's chat history KB; indexing now uses the session owner's configuration. - Sharing an agent with skills keeps injecting the owner's skill environment values (product decision); the share panel now warns that members can read them. Preview of originals through read-only shares is kept as designed and documented.
2026-09-18 14:00:02 +00:00
package handler
import (
"context"
stderrors "errors"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/Tencent/WeKnora/internal/application/access"
"github.com/Tencent/WeKnora/internal/config"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/middleware"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/require"
)
type stubInitializationKBService struct {
interfaces.KnowledgeBaseService
kb *types.KnowledgeBase
}
func (s *stubInitializationKBService) GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error) {
return s.kb, nil
}
func requireForbidden(t *testing.T, err error) {
t.Helper()
var appErr *apperrors.AppError
if !stderrors.As(err, &appErr) || appErr.HTTPCode != http.StatusForbidden {
t.Fatalf("err = %v, want 403", err)
}
}
// A shared-KB editor reaches the handler with execution moved into the owner
// workspace; the KB must still be refused because the caller does not own it.
func TestInitializationRejectsKBOfAnotherWorkspace(t *testing.T) {
h := &InitializationHandler{kbService: &stubInitializationKBService{
kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 7},
}}
ctx := types.WithCaller(context.Background(), types.Caller{TenantID: 42, UserID: "u", Role: types.TenantRoleOwner})
ctx = types.WithExecutionTenant(ctx, 7)
_, err := h.getKnowledgeBaseForInitialization(ctx, "kb-1")
requireForbidden(t, err)
}
func TestInitializationAllowsOwnKB(t *testing.T) {
h := &InitializationHandler{kbService: &stubInitializationKBService{
kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 42},
}}
ctx := types.WithCaller(context.Background(),
types.Caller{TenantID: 42, UserID: "u", Role: types.TenantRoleContributor})
if _, err := h.getKnowledgeBaseForInitialization(ctx, "kb-1"); err != nil {
t.Fatalf("own KB rejected: %v", err)
}
}
// Rewriting an already-stored model needs the same authority as PUT
// /models/:id; creating the KB's first models does not.
func TestInitializationExistingModelUpdateRequiresModelAuthority(t *testing.T) {
enforced := true
stored := &types.Model{ID: "m-existing", Type: types.ModelTypeKnowledgeQA, TenantID: 42}
kb := &types.KnowledgeBase{ID: "kb-1", TenantID: 42, SummaryModelID: "m-existing"}
caller := func(role types.TenantRole) context.Context {
return types.WithCaller(context.Background(), types.Caller{TenantID: 42, UserID: "u", Role: role})
}
scopedKey := func(capability types.APIKeyCapability) context.Context {
scope := types.TenantAPIKeyScope{Capabilities: types.StringArray{string(capability)}}
return types.WithTenantAPIKeyScope(caller(types.TenantRoleViewer), scope)
}
cases := []struct {
name string
ctx context.Context
allowed bool
}{
{"contributor", caller(types.TenantRoleContributor), false},
{"admin", caller(types.TenantRoleAdmin), true},
{"scoped key without manage_models", scopedKey(types.APIKeyCapabilityManageKnowledgeBases), false},
{"scoped key with manage_models", scopedKey(types.APIKeyCapabilityManageModels), true},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
svc := &stubTenantStampModelService{getModelByID: func(_ context.Context, id string) (*types.Model, error) {
if id == stored.ID {
copied := *stored
return &copied, nil
}
return nil, nil
}}
h := &InitializationHandler{
modelService: svc,
config: &config.Config{Tenant: &config.TenantConfig{EnableRBAC: &enforced}},
}
_, err := h.processInitializationModels(tc.ctx, kb, "kb-1", newTenantStampRequest())
if tc.allowed {
if err != nil || len(svc.updated) != 1 {
t.Fatalf("err = %v, updated = %d, want one update", err, len(svc.updated))
}
return
}
requireForbidden(t, err)
if len(svc.updated) != 0 {
t.Fatalf("model was updated despite missing authority")
}
})
}
}
type stubInitializationKBRepo struct {
interfaces.KnowledgeBaseRepository
updated *types.KnowledgeBase
}
func (r *stubInitializationKBRepo) UpdateKnowledgeBase(_ context.Context, kb *types.KnowledgeBase) error {
r.updated = kb
return nil
}
// PUT /initialization/config shares the route guard (KBAccessWrite) that
// admits share editors. KB settings belong to the owner and to admin shares
// only, and a share admin still cannot rebind the owner's storage.
func TestUpdateKBConfigFromAnotherWorkspace(t *testing.T) {
backend := "backend-of-owner"
cases := []struct {
name string
permission types.OrgMemberRole
body string
wantStatus int
}{
{
name: "share editor", permission: types.OrgRoleEditor,
body: `{"llmModelId":"m-llm"}`, wantStatus: http.StatusForbidden,
},
{
name: "share admin rebinding storage", permission: types.OrgRoleAdmin,
body: `{"llmModelId":"m-llm","storageBackendId":"backend-of-receiver"}`, wantStatus: http.StatusForbidden,
},
{
name: "share admin keeping storage", permission: types.OrgRoleAdmin,
body: `{"llmModelId":"m-llm","storageBackendId":"backend-of-owner","storageProvider":"minio"}`,
wantStatus: http.StatusOK,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
kb := &types.KnowledgeBase{ID: "kb-1", TenantID: 7, StorageBackendID: &backend}
repo := &stubInitializationKBRepo{}
models := &stubTenantStampModelService{getModelByID: func(context.Context, string) (*types.Model, error) {
return &types.Model{ID: "m-llm", TenantID: 7}, nil
}}
h := &InitializationHandler{
kbService: &stubInitializationKBService{kb: kb},
kbRepository: repo,
modelService: models,
}
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
c, _ := gin.CreateTestContext(recorder)
c.Params = gin.Params{{Key: "kbId", Value: "kb-1"}}
req := httptest.NewRequest(http.MethodPut, "/", strings.NewReader(tc.body))
req.Header.Set("Content-Type", "application/json")
caller := types.Caller{TenantID: 42, UserID: "u", Role: types.TenantRoleAdmin}
ctx := types.WithExecutionTenant(types.WithCaller(req.Context(), caller), 7)
c.Request = req.WithContext(ctx)
c.Set(middleware.KBAccessContextKey, &access.KBAccess{
KnowledgeBase: kb, Caller: caller, EffectiveTenantID: 7, Permission: tc.permission,
})
h.UpdateKBConfig(c)
if tc.wantStatus == http.StatusOK {
require.Empty(t, c.Errors)
require.NotNil(t, repo.updated)
require.Equal(t, backend, *repo.updated.StorageBackendID)
return
}
require.Len(t, c.Errors, 1)
requireForbidden(t, c.Errors[0].Err)
require.Nil(t, repo.updated, "KB must not be written")
})
}
}