refactor(rbac): address kb-access guard review findings

Follow-up to the route-level KB-access guard introduced earlier in
this PR. Five reviewer findings, all fixed in middleware + tests
without changing handler call sites:

  - Honour `?agent_id` in the agent-share fallback. The in-handler
    resolution in knowledgebase.go branches on a specific agent's
    KBSelectionMode (all / selected / none); the guard was only ever
    calling TenantCanAccessKBViaSomeSharedAgent, which let some
    requests pass at the guard layer that the handler would then
    reject — and rewrote the request's tenant context to the source
    tenant before the rejection happened. The guard now mirrors the
    handler: a specific agent_id pins the resolution to that agent
    (no fallback to any-agent), an empty agent_id keeps the existing
    any-agent behaviour. The knowledge.go / knowledgebase.go handler
    helpers stay in place as defence in depth until they're folded
    into the guard in a follow-up.

  - Distinguish not-found vs. transient on the knowledge / chunk
    resolvers. A DB hiccup used to surface as a 404, both confusing
    clients and hiding the underlying failure from monitoring. The
    resolvers now return apperror 404 only for the known not-found
    sentinels (apprepo.ErrKnowledgeBaseNotFound, ErrResourceNotFound)
    and let other errors propagate; the guard maps those to a fresh
    NewServiceUnavailableError (503).

  - Stop 500-ing on legacy chunks with empty knowledge_base_id. The
    chunk is effectively unresolvable to a KB, so the client gets the
    same 404 they'd get for a missing chunk instead of a 500 that
    pollutes alerting. The warn log preserves the operator signal.

  - Honour cfg.Tenant.EnableRBAC. The guard now mirrors RequireRole /
    RequireOwnershipOrRole: with enforcement off, 401/403 paths log
    the would-be rejection and pass through. 404 still fires either
    way (a missing resource is not an authorisation event). Keeps the
    rollout window safe — operators can flip enforcement on globally
    without code changes elsewhere.

  - Document the c.Keys vs. c.Request.Context() split. The guard
    intentionally rewrites only the request context (handlers that
    still run their own share resolution, currently knowledge.go /
    knowledgebase.go, would otherwise see kb.TenantID == c.Keys
    tenant and misclassify shared-Viewer access as Admin). The
    package-level comment now spells this out so the migration of the
    remaining handlers in a follow-up doesn't accidentally regress
    `my_permission` rendering.

Tests:

  - Existing four cases keep working; runGuard signature gained a
    guardOpts knob.
  - Eight new cases cover the agent-share resolution paths (any-agent
    viewer, Editor required → must reject, specific agent in modes
    all / selected-match / selected-miss / none, cross-tenant
    mismatch) plus the EnableRBAC=false fail-open + 404-still-fires
    pair.
This commit is contained in:
wizardchen
2026-05-15 23:26:54 +08:00
committed by lyingbug
parent ef01f99e69
commit 8efe1b4187
4 changed files with 525 additions and 26 deletions
+13
View File
@@ -122,6 +122,19 @@ func NewInternalServerError(message string) *AppError {
}
}
// NewServiceUnavailableError creates a service unavailable (503)
// error. Used for transient failures where the caller can retry.
func NewServiceUnavailableError(message string) *AppError {
if message == "" {
message = "服务暂时不可用"
}
return &AppError{
Code: ErrServiceUnavailable,
Message: message,
HTTPCode: http.StatusServiceUnavailable,
}
}
// NewValidationError creates a validation error
func NewValidationError(message string) *AppError {
return &AppError{
+173 -18
View File
@@ -5,6 +5,7 @@ import (
stderrors "errors"
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/config"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
@@ -33,6 +34,22 @@ import (
// Plan 3's 3-D cap (tenant Viewer pinned to OrgRoleViewer) is enforced
// inside CheckTenantKBPermission itself, so the guard here just
// propagates the result.
//
// ⚠️ Tenant id has TWO surfaces on a gin.Context:
//
// - c.Request.Context() (read via types.TenantIDFromContext)
// - c.Keys[TenantIDContextKey] (read via c.Get / c.GetUint64)
//
// The guard rewrites ONLY the request context — c.Keys is intentionally
// left at the caller's own tenant so handlers that still run their own
// share resolution (currently knowledge.go / knowledgebase.go, which
// branch on the ?agent_id query) keep working unchanged. New handlers
// MUST read tenant from c.Request.Context() (the "effective" tenant
// for shared KBs); reading from c.Keys after this guard runs gives
// the caller's own tenant, which is almost always the wrong answer
// for KB-scoped routes. The FAQ / Tag / Chunk handlers in this PR
// were converted to the ctx-based read; the migration of knowledge.go
// / knowledgebase.go is a follow-up.
// KBAccess captures the result of a successful KB access resolution.
// Stashed on gin.Context under KBAccessContextKey so handlers that
@@ -87,6 +104,10 @@ type ChunkLookup interface {
// KBIDResolver tells the guard how to find the kb_id for a given
// request. Built-in resolvers below cover the param shapes we use:
// :id, :kb_id, :kbId, :knowledge_id (-> parent KB).
//
// On error, resolvers MUST return either a 4xx apperror (bad request /
// not found) or a generic Go error for transient/internal failures;
// the guard maps the latter to 503.
type KBIDResolver func(c *gin.Context) (string, error)
// KBIDFromParam returns a resolver that reads a fixed gin param.
@@ -103,6 +124,11 @@ func KBIDFromParam(param string) KBIDResolver {
// KBIDFromKnowledgeIDParam reads `:knowledge_id` from the URL, looks
// up the knowledge document, and returns its KB id. Used by the chunk
// routes that address a chunk via /chunks/:knowledge_id.
//
// A genuine "not found" maps to 404; transient errors (DB hiccup,
// service unavailable) are surfaced as a plain Go error so the guard
// can return 503 instead of pretending the resource doesn't exist
// (a 404 here would also short-circuit any retry / monitoring).
func KBIDFromKnowledgeIDParam(param string, kgService KnowledgeLookup) KBIDResolver {
return func(c *gin.Context) (string, error) {
v := c.Param(param)
@@ -110,7 +136,13 @@ func KBIDFromKnowledgeIDParam(param string, kgService KnowledgeLookup) KBIDResol
return "", apperrors.NewBadRequestError("missing " + param + " in path")
}
k, err := kgService.GetKnowledgeByIDOnly(c.Request.Context(), v)
if err != nil || k == nil {
if err != nil {
if isResourceNotFound(err) {
return "", apperrors.NewNotFoundError("Knowledge not found")
}
return "", err
}
if k == nil {
return "", apperrors.NewNotFoundError("Knowledge not found")
}
return k.KnowledgeBaseID, nil
@@ -121,6 +153,8 @@ func KBIDFromKnowledgeIDParam(param string, kgService KnowledgeLookup) KBIDResol
// Used by /chunks/by-id/:id routes that address a chunk directly. The
// chunk's KnowledgeBaseID is denormalised on the row, so a single
// lookup is enough — no need to chain through GetKnowledgeByIDOnly.
//
// Not-found / transient split mirrors KBIDFromKnowledgeIDParam.
func KBIDFromChunkIDParam(param string, chunkService ChunkLookup) KBIDResolver {
return func(c *gin.Context) (string, error) {
v := c.Param(param)
@@ -128,18 +162,37 @@ func KBIDFromChunkIDParam(param string, chunkService ChunkLookup) KBIDResolver {
return "", apperrors.NewBadRequestError("missing " + param + " in path")
}
ch, err := chunkService.GetChunkByIDOnly(c.Request.Context(), v)
if err != nil || ch == nil {
if err != nil {
if isResourceNotFound(err) {
return "", apperrors.NewNotFoundError("Chunk not found")
}
return "", err
}
if ch == nil {
return "", apperrors.NewNotFoundError("Chunk not found")
}
if ch.KnowledgeBaseID == "" {
// Some old chunks may not carry the denormalised KB id;
// this is a should-never-happen branch on a fresh schema.
return "", apperrors.NewInternalServerError("chunk missing knowledge_base_id")
// Should-never-happen on a fresh schema; on legacy rows the
// chunk effectively isn't resolvable to a KB so the client
// gets the same 404 they'd get for a missing chunk rather
// than a 500 that pollutes alerting.
logger.Warnf(c.Request.Context(),
"[kb_access] chunk %s has empty knowledge_base_id; treating as not-found", v)
return "", apperrors.NewNotFoundError("Chunk not found")
}
return ch.KnowledgeBaseID, nil
}
}
// isResourceNotFound recognises the various "not found" sentinels we
// might see from the underlying services. Keeps the resolvers above
// from forcing every service to standardise on a single error type
// before this refactor is useful.
func isResourceNotFound(err error) bool {
return stderrors.Is(err, apprepo.ErrKnowledgeBaseNotFound) ||
stderrors.Is(err, ErrResourceNotFound)
}
// RequireKBAccess returns a gin.HandlerFunc that resolves KB access
// (own / org-shared / via shared agent), enforces the minimum required
// org-level permission, and on success stores the result under
@@ -148,24 +201,32 @@ func KBIDFromChunkIDParam(param string, chunkService ChunkLookup) KBIDResolver {
// context as before.
//
// On failure the guard aborts with the appropriate HTTP status (400 /
// 401 / 404 / 403 / 500). Behaviour matches what each handler's
// 401 / 404 / 403 / 503). Behaviour matches what each handler's
// effectiveCtxForKB helper used to do; the guard is what consolidates
// the repetition so a fix in the resolution order propagates to every
// gated route at once.
//
// Required permission semantics:
// - OrgRoleViewer -> read-only routes (the agent-share fallback path
// activates only at this level)
// activates only at this level)
// - OrgRoleEditor -> mutating routes (org-shared editor or own KB)
// - OrgRoleAdmin -> share-management routes (only the original
// sharer / KB owner / Org admin should pass)
// sharer / KB owner / Org admin should pass)
//
// When cfg.Tenant.EnableRBAC is false the guard mirrors the sibling
// role/ownership guards: it logs the would-be rejection and lets the
// request through. The point is to keep the rollout window safe — the
// guard runs full enforcement once the flag flips on, with no code
// changes elsewhere.
func RequireKBAccess(
resolveKBID KBIDResolver,
requiredPermission types.OrgMemberRole,
kbService KBLookup,
kbShareService interfaces.KBShareService,
agentShareService interfaces.AgentShareService,
cfg *config.Config,
) gin.HandlerFunc {
warnOnNilConfig(cfg)
return func(c *gin.Context) {
kbID, err := resolveKBID(c)
if err != nil {
@@ -175,23 +236,47 @@ func RequireKBAccess(
}
ctx := c.Request.Context()
access, err := resolveKBAccessOnce(ctx, kbID, requiredPermission, kbService, kbShareService, agentShareService)
// Rollout window: enforcement off -> log the would-be check and
// pass through. We still resolve the KB (best-effort) so the
// effective-tenant context rewrite still happens for shared
// KBs; that way embedding queries hit the right tenant
// regardless of whether RBAC enforcement is active.
enforcing := rbacEnforcementEnabled(cfg)
access, err := resolveKBAccessOnce(ctx, c, kbID, requiredPermission, kbService, kbShareService, agentShareService)
switch {
case stderrors.Is(err, errKBAccessUnauthorized):
if !enforcing {
logger.Warnf(ctx, "[rbac] kb-access would 401 (enforcement off): kb=%s", kbID)
c.Next()
return
}
_ = c.Error(apperrors.NewUnauthorizedError("Unauthorized"))
c.Abort()
return
case stderrors.Is(err, errKBAccessNotFound):
// 404 still fires when enforcement is off — a missing KB is
// not an authorisation event, the client genuinely asked
// for nothing.
_ = c.Error(apperrors.NewNotFoundError("knowledge base not found"))
c.Abort()
return
case stderrors.Is(err, errKBAccessForbidden):
if !enforcing {
logger.Warnf(ctx, "[rbac] kb-access would 403 (enforcement off): kb=%s required=%s",
kbID, requiredPermission)
c.Next()
return
}
_ = c.Error(apperrors.NewForbiddenError("Permission denied to access this knowledge base"))
c.Abort()
return
case err != nil:
logger.ErrorWithFields(ctx, err, nil)
_ = c.Error(apperrors.NewInternalServerError(err.Error()))
// Transient/internal -> 503 so monitoring catches the
// underlying failure rather than a misleading 500.
_ = c.Error(apperrors.NewServiceUnavailableError("cannot verify KB access right now"))
c.Abort()
return
}
@@ -210,8 +295,17 @@ func RequireKBAccess(
// resolveKBAccessOnce performs the actual three-step resolution. Kept
// unexported and using package-private sentinel errors so the guard's
// error mapping is the only public surface.
//
// The shared-agent step honours the ?agent_id query parameter when
// present, mirroring the in-handler resolution in
// knowledgebase.go's validateAndGetKnowledgeBase: a request with a
// specific agent_id is validated against THAT agent's KB scope (mode =
// all / selected / none), not against "any shared agent". Falling
// back to "any shared agent" when agent_id is empty preserves the
// "通过智能体可见" KB list entry point.
func resolveKBAccessOnce(
ctx context.Context,
c *gin.Context,
kbID string,
requiredPermission types.OrgMemberRole,
kbService KBLookup,
@@ -265,14 +359,8 @@ func resolveKBAccessOnce(
// 3. Shared agent that carries this KB — only ever grants read.
if requiredPermission == types.OrgRoleViewer && agentShareService != nil {
can, err := agentShareService.TenantCanAccessKBViaSomeSharedAgent(ctx, tenantID, callerTenantRole, kb)
if err == nil && can {
logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via shared agent", tenantID, kbID)
return &KBAccess{
KnowledgeBase: kb,
EffectiveTenantID: kb.TenantID,
Permission: types.OrgRoleViewer,
}, nil
if access := resolveSharedAgentAccess(ctx, c, tenantID, callerTenantRole, kb, agentShareService); access != nil {
return access, nil
}
}
@@ -280,6 +368,73 @@ func resolveKBAccessOnce(
return nil, errKBAccessForbidden
}
// resolveSharedAgentAccess implements the agent-share fallback,
// mirroring knowledgebase.go's in-handler logic so the guard and the
// (still-present) handler resolver agree on which requests pass.
//
// - If ?agent_id=X is provided, validate against THAT agent's
// KBSelectionMode (all / selected / none). A mismatch means deny;
// we do NOT fall back to "any shared agent" because the client
// explicitly named one (typically from a @-mention or a deep link
// scoped to that agent).
// - If ?agent_id is empty, allow when any shared agent reachable by
// the caller can access this KB ("通过智能体可见" KB list entry).
func resolveSharedAgentAccess(
ctx context.Context,
c *gin.Context,
tenantID uint64,
callerTenantRole types.TenantRole,
kb *types.KnowledgeBase,
agentShareService interfaces.AgentShareService,
) *KBAccess {
agentID := c.Query("agent_id")
if agentID != "" {
agent, err := agentShareService.GetSharedAgentForTenant(ctx, tenantID, callerTenantRole, agentID)
if err != nil || agent == nil {
return nil
}
if kb.TenantID != agent.TenantID {
logger.Warnf(ctx, "[kb_access] shared agent tenant mismatch: kb=%s kb.tenant=%d agent.tenant=%d",
kb.ID, kb.TenantID, agent.TenantID)
return nil
}
switch agent.Config.KBSelectionMode {
case "all":
logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via shared agent %s (mode=all)",
tenantID, kb.ID, agentID)
return &KBAccess{
KnowledgeBase: kb,
EffectiveTenantID: kb.TenantID,
Permission: types.OrgRoleViewer,
}
case "selected":
for _, allowedID := range agent.Config.KnowledgeBases {
if allowedID == kb.ID {
logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via shared agent %s (mode=selected)",
tenantID, kb.ID, agentID)
return &KBAccess{
KnowledgeBase: kb,
EffectiveTenantID: kb.TenantID,
Permission: types.OrgRoleViewer,
}
}
}
}
return nil
}
can, err := agentShareService.TenantCanAccessKBViaSomeSharedAgent(ctx, tenantID, callerTenantRole, kb)
if err == nil && can {
logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via some shared agent", tenantID, kb.ID)
return &KBAccess{
KnowledgeBase: kb,
EffectiveTenantID: kb.TenantID,
Permission: types.OrgRoleViewer,
}
}
return nil
}
var (
errKBAccessUnauthorized = stderrors.New("kb_access: unauthorized")
errKBAccessNotFound = stderrors.New("kb_access: not found")
+333 -8
View File
@@ -8,6 +8,7 @@ import (
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/require"
)
@@ -94,15 +95,96 @@ func (s *stubKBShareForGuard) CountByOrganizations(context.Context, []string) (m
panic("not implemented")
}
// stubAgentShareForGuard implements just the two methods the guard
// touches: GetSharedAgentForTenant (when ?agent_id=X is supplied) and
// TenantCanAccessKBViaSomeSharedAgent (the any-shared-agent fallback).
// Every other method panics so unintended new dependencies surface
// immediately.
type stubAgentShareForGuard struct {
// agents indexed by agent id; nil entry means GetSharedAgentForTenant
// returns nil + nil (i.e. caller has no access to that agent id).
agents map[string]*types.CustomAgent
// kbsViaSomeAgent[kb.ID] -> true means the any-agent fallback grants
// access to that KB.
kbsViaSomeAgent map[string]bool
}
func (s *stubAgentShareForGuard) GetSharedAgentForTenant(_ context.Context, _ uint64, _ types.TenantRole, agentID string) (*types.CustomAgent, error) {
return s.agents[agentID], nil
}
func (s *stubAgentShareForGuard) TenantCanAccessKBViaSomeSharedAgent(_ context.Context, _ uint64, _ types.TenantRole, kb *types.KnowledgeBase) (bool, error) {
return s.kbsViaSomeAgent[kb.ID], nil
}
func (s *stubAgentShareForGuard) ShareAgent(context.Context, string, string, string, uint64, types.OrgMemberRole) (*types.AgentShare, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) RemoveShare(context.Context, string, string, uint64) error {
panic("not implemented")
}
func (s *stubAgentShareForGuard) ListSharesByAgent(context.Context, string) ([]*types.AgentShare, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) ListSharesByOrganization(context.Context, string) ([]*types.AgentShare, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) ListSharedAgents(context.Context, uint64, types.TenantRole) ([]*types.SharedAgentInfo, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) ListSharedAgentsInOrganization(context.Context, string, uint64, types.TenantRole) ([]*types.OrganizationSharedAgentItem, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) ListSharedAgentsInOrganizations(context.Context, []string, uint64, types.TenantRole) (map[string][]*types.OrganizationSharedAgentItem, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) SetSharedAgentDisabledByMe(context.Context, uint64, string, uint64, bool) error {
panic("not implemented")
}
func (s *stubAgentShareForGuard) GetShare(context.Context, string) (*types.AgentShare, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) GetShareByAgentAndOrg(context.Context, string, string) (*types.AgentShare, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) GetShareByAgentIDForTenant(context.Context, uint64, string, uint64) (*types.AgentShare, error) {
panic("not implemented")
}
func (s *stubAgentShareForGuard) CountByOrganizations(context.Context, []string) (map[string]int64, error) {
panic("not implemented")
}
// guardOpts collects optional knobs for runGuard. Keeps the call site
// readable when most tests only care about a couple of dimensions.
type guardOpts struct {
agentID string // ?agent_id query param
agentShare *stubAgentShareForGuard // nil means "no agent-share service"
}
// runGuard fires a single request through the guard and returns the
// gin recorder + the kb access (if any) the guard stashed.
func runGuard(t *testing.T, tenantID uint64, kbID string, requiredPerm types.OrgMemberRole, kb *types.KnowledgeBase, share *stubKBShareForGuard) (*httptest.ResponseRecorder, *gin.Context) {
// gin recorder + the kb access (if any) the guard stashed. Defaults
// to EnableRBAC=true; the EnableRBAC=false fail-open path has its own
// dedicated tests further below.
func runGuard(
t *testing.T,
tenantID uint64,
kbID string,
requiredPerm types.OrgMemberRole,
kb *types.KnowledgeBase,
share *stubKBShareForGuard,
opts guardOpts,
) (*httptest.ResponseRecorder, *gin.Context) {
t.Helper()
gin.SetMode(gin.TestMode)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Params = gin.Params{{Key: "id", Value: kbID}}
req := httptest.NewRequest("GET", "/", nil)
url := "/"
if opts.agentID != "" {
url = "/?agent_id=" + opts.agentID
}
req := httptest.NewRequest("GET", url, nil)
ctx := context.WithValue(req.Context(), types.TenantIDContextKey, tenantID)
c.Request = req.WithContext(ctx)
@@ -110,7 +192,28 @@ func runGuard(t *testing.T, tenantID uint64, kbID string, requiredPerm types.Org
if kb != nil {
kbsvc.kbs[kbID] = kb
}
guard := RequireKBAccess(KBIDFromParam("id"), requiredPerm, kbsvc, share, nil)
// Convert the package-local concrete stub types to typed interface
// nils when they aren't supplied — otherwise the interface wraps a
// nil pointer and `iface != nil` evaluates true on the guard side
// (classic Go typed-nil trap).
var shareSvc interfaces.KBShareService
if share != nil {
shareSvc = share
}
var agentSvc interfaces.AgentShareService
if opts.agentShare != nil {
agentSvc = opts.agentShare
}
guard := RequireKBAccess(
KBIDFromParam("id"),
requiredPerm,
kbsvc,
shareSvc,
agentSvc,
cfgRBAC(true),
)
guard(c)
return rec, c
}
@@ -120,6 +223,7 @@ func TestRequireKBAccess_OwnKB(t *testing.T) {
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-1", TenantID: 100},
nil,
guardOpts{},
)
require.False(t, c.IsAborted(), "should pass through")
require.Equal(t, 200, rec.Code) // gin's default; nothing wrote a status
@@ -134,12 +238,11 @@ func TestRequireKBAccess_OwnKB(t *testing.T) {
}
func TestRequireKBAccess_NotFound_Aborts(t *testing.T) {
rec, c := runGuard(t, 100, "kb-missing", types.OrgRoleViewer, nil, nil)
_, c := runGuard(t, 100, "kb-missing", types.OrgRoleViewer, nil, nil, guardOpts{})
require.True(t, c.IsAborted(), "missing KB must abort")
require.NotEmpty(t, c.Errors)
_, ok := KBAccessFromContext(c)
require.False(t, ok, "no access should be stashed on failure")
_ = rec
}
func TestRequireKBAccess_SharedKB_RewritesTenantContext(t *testing.T) {
@@ -152,12 +255,12 @@ func TestRequireKBAccess_SharedKB_RewritesTenantContext(t *testing.T) {
types.OrgRoleEditor,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
share,
guardOpts{},
)
require.False(t, c.IsAborted())
access, ok := KBAccessFromContext(c)
require.True(t, ok)
require.Equal(t, uint64(200), access.EffectiveTenantID)
// The downstream handler should see tenant=200 from context.
got, _ := types.TenantIDFromContext(c.Request.Context())
require.Equal(t, uint64(200), got, "guard must rewrite context to source tenant")
}
@@ -172,6 +275,7 @@ func TestRequireKBAccess_SharedKB_PermissionBelowMin_Aborts(t *testing.T) {
types.OrgRoleEditor, // require Editor
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
share,
guardOpts{},
)
require.True(t, c.IsAborted(), "Viewer share must reject when Editor required")
}
@@ -182,7 +286,228 @@ func TestRequireKBAccess_NoTenant_Aborts(t *testing.T) {
c, _ := gin.CreateTestContext(rec)
c.Params = gin.Params{{Key: "id", Value: "kb-x"}}
c.Request = httptest.NewRequest("GET", "/", nil) // no tenant in context
guard := RequireKBAccess(KBIDFromParam("id"), types.OrgRoleViewer, &stubKBLookup{}, nil, nil)
guard := RequireKBAccess(
KBIDFromParam("id"),
types.OrgRoleViewer,
&stubKBLookup{},
nil,
nil,
cfgRBAC(true),
)
guard(c)
require.True(t, c.IsAborted())
}
// ---------- Agent-share fallback ----------
func TestRequireKBAccess_AgentShare_AnyAgent_ViewerOnly(t *testing.T) {
// No org-share entry; caller has at least one shared agent that can
// access this KB. Required permission is Viewer, so the agent-share
// branch activates and grants read access at the source tenant.
agent := &stubAgentShareForGuard{
kbsViaSomeAgent: map[string]bool{"kb-shared": true},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent},
)
require.False(t, c.IsAborted())
access, ok := KBAccessFromContext(c)
require.True(t, ok)
require.Equal(t, uint64(200), access.EffectiveTenantID)
require.Equal(t, types.OrgRoleViewer, access.Permission, "agent share grants viewer only")
}
func TestRequireKBAccess_AgentShare_EditorRequired_Aborts(t *testing.T) {
// Required permission is Editor → agent-share fallback MUST NOT
// activate. Regression test for the implicit-security-fix in this
// PR: old TagHandler.effectiveCtxForKB granted any agent-share
// access to write routes, which leaked tag CRUD.
agent := &stubAgentShareForGuard{
kbsViaSomeAgent: map[string]bool{"kb-shared": true},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleEditor,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent},
)
require.True(t, c.IsAborted(), "agent share must NOT satisfy Editor requirement")
}
func TestRequireKBAccess_AgentShare_SpecificAgent_ModeAll(t *testing.T) {
// ?agent_id=A and A has KBSelectionMode=all on the source tenant.
// Guard should accept regardless of which KB.
agent := &stubAgentShareForGuard{
agents: map[string]*types.CustomAgent{
"agent-A": {
ID: "agent-A",
TenantID: 200,
Config: types.CustomAgentConfig{
KBSelectionMode: "all",
},
},
},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent, agentID: "agent-A"},
)
require.False(t, c.IsAborted())
access, _ := KBAccessFromContext(c)
require.Equal(t, types.OrgRoleViewer, access.Permission)
}
func TestRequireKBAccess_AgentShare_SpecificAgent_ModeSelected_Match(t *testing.T) {
agent := &stubAgentShareForGuard{
agents: map[string]*types.CustomAgent{
"agent-A": {
ID: "agent-A",
TenantID: 200,
Config: types.CustomAgentConfig{
KBSelectionMode: "selected",
KnowledgeBases: []string{"kb-other", "kb-shared"},
},
},
},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent, agentID: "agent-A"},
)
require.False(t, c.IsAborted())
}
func TestRequireKBAccess_AgentShare_SpecificAgent_ModeSelected_Miss(t *testing.T) {
// ?agent_id=A but A's selected list does NOT include this KB. Even
// though SOME OTHER shared agent (B) would have granted access via
// the any-agent fallback, the explicit agent_id pins the resolution
// to A. This is the divergence the review flagged.
agent := &stubAgentShareForGuard{
agents: map[string]*types.CustomAgent{
"agent-A": {
ID: "agent-A",
TenantID: 200,
Config: types.CustomAgentConfig{
KBSelectionMode: "selected",
KnowledgeBases: []string{"kb-other"},
},
},
},
// any-agent fallback would have said yes — but agent_id=A pins us.
kbsViaSomeAgent: map[string]bool{"kb-shared": true},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent, agentID: "agent-A"},
)
require.True(t, c.IsAborted(), "agent_id=A must NOT fall back to any-agent")
}
func TestRequireKBAccess_AgentShare_SpecificAgent_ModeNone(t *testing.T) {
agent := &stubAgentShareForGuard{
agents: map[string]*types.CustomAgent{
"agent-A": {
ID: "agent-A",
TenantID: 200,
Config: types.CustomAgentConfig{
KBSelectionMode: "none",
},
},
},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent, agentID: "agent-A"},
)
require.True(t, c.IsAborted(), "agent in mode=none must not grant access")
}
func TestRequireKBAccess_AgentShare_SpecificAgent_TenantMismatch(t *testing.T) {
// Agent belongs to tenant 999 but KB belongs to tenant 200 → reject
// (this is the kb.TenantID != agent.TenantID guard in the handler;
// preserves cross-tenant isolation when shares get reshuffled).
agent := &stubAgentShareForGuard{
agents: map[string]*types.CustomAgent{
"agent-A": {
ID: "agent-A",
TenantID: 999,
Config: types.CustomAgentConfig{
KBSelectionMode: "all",
},
},
},
}
_, c := runGuard(t, 100, "kb-shared",
types.OrgRoleViewer,
&types.KnowledgeBase{ID: "kb-shared", TenantID: 200},
nil,
guardOpts{agentShare: agent, agentID: "agent-A"},
)
require.True(t, c.IsAborted())
}
// ---------- EnableRBAC=false rollout window ----------
func TestRequireKBAccess_Forbidden_FailOpenWhenRBACDisabled(t *testing.T) {
// Same scenario as PermissionBelowMin (which aborts when enforcing),
// but with EnableRBAC=false the guard logs and passes through.
gin.SetMode(gin.TestMode)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Params = gin.Params{{Key: "id", Value: "kb-shared"}}
req := httptest.NewRequest("GET", "/", nil)
c.Request = req.WithContext(context.WithValue(req.Context(), types.TenantIDContextKey, uint64(100)))
share := &stubKBShareForGuard{
permission: map[string]types.OrgMemberRole{"kb-shared": types.OrgRoleViewer},
shared: map[string]bool{"kb-shared": true},
source: map[string]uint64{"kb-shared": 200},
}
kbsvc := &stubKBLookup{kbs: map[string]*types.KnowledgeBase{
"kb-shared": {ID: "kb-shared", TenantID: 200},
}}
guard := RequireKBAccess(
KBIDFromParam("id"),
types.OrgRoleEditor, // would-deny
kbsvc, share, nil,
cfgRBAC(false), // enforcement off
)
guard(c)
require.False(t, c.IsAborted(), "guard must pass through when EnableRBAC is off")
_ = rec
}
func TestRequireKBAccess_NotFound_FiresEvenWhenRBACDisabled(t *testing.T) {
// Not-found is not an authorisation event; the client asked for a
// resource that genuinely isn't there. We surface 404 regardless of
// the rollout flag (matches the comment in RequireKBAccess).
gin.SetMode(gin.TestMode)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Params = gin.Params{{Key: "id", Value: "kb-missing"}}
req := httptest.NewRequest("GET", "/", nil)
c.Request = req.WithContext(context.WithValue(req.Context(), types.TenantIDContextKey, uint64(100)))
guard := RequireKBAccess(
KBIDFromParam("id"),
types.OrgRoleViewer,
&stubKBLookup{kbs: map[string]*types.KnowledgeBase{}},
nil, nil,
cfgRBAC(false),
)
guard(c)
require.True(t, c.IsAborted(), "404 still fires with enforcement off")
_ = rec
}
+6
View File
@@ -320,6 +320,7 @@ func (g *rbacGuards) KBAccessRead(param string) gin.HandlerFunc {
g.kbService,
g.kbShareService,
g.agentShareService,
g.cfg,
)
}
@@ -333,6 +334,7 @@ func (g *rbacGuards) KBAccessWrite(param string) gin.HandlerFunc {
g.kbService,
g.kbShareService,
g.agentShareService,
g.cfg,
)
}
@@ -347,6 +349,7 @@ func (g *rbacGuards) KBAccessReadFromKnowledgeIDParam(param string) gin.HandlerF
g.kbService,
g.kbShareService,
g.agentShareService,
g.cfg,
)
}
@@ -359,6 +362,7 @@ func (g *rbacGuards) KBAccessWriteFromKnowledgeIDParam(param string) gin.Handler
g.kbService,
g.kbShareService,
g.agentShareService,
g.cfg,
)
}
@@ -372,6 +376,7 @@ func (g *rbacGuards) KBAccessReadFromChunkIDParam(param string) gin.HandlerFunc
g.kbService,
g.kbShareService,
g.agentShareService,
g.cfg,
)
}
@@ -385,5 +390,6 @@ func (g *rbacGuards) KBAccessWriteFromChunkIDParam(param string) gin.HandlerFunc
g.kbService,
g.kbShareService,
g.agentShareService,
g.cfg,
)
}