fix(files): serve shared KB images via KB-scoped file proxy

Org-shared and agent-visible knowledge bases store images under the owner
tenant's storage path, which the tenant-scoped /files route rejects for
borrowing tenants. Add GET /api/v1/knowledge-bases/:id/files gated by
RequireKBAccess and route frontend image hydration through it when kbId
is known.
This commit is contained in:
wizardchen
2026-07-13 11:29:37 +08:00
committed by lyingbug
parent abcecc870a
commit 800cea0826
6 changed files with 262 additions and 8 deletions
+2 -2
View File
@@ -84,7 +84,7 @@ mermaid.initialize({
topPadding: 50
}
});
const props = defineProps(["visible", "details", "knowledgeType", "sourceInfo", "canEditKB", "parse_status"]);
const props = defineProps(["visible", "details", "knowledgeType", "sourceInfo", "canEditKB", "parse_status", "kbId"]);
const emit = defineEmits(["closeDoc", "getDoc", "questionDeleted"]);
const hasTimelineSpans = ref(false);
@@ -618,7 +618,7 @@ const runMarkdownPostRenderPipeline = async () => {
if (!renderRoot) {
return;
}
await hydrateProtectedFileImages(renderRoot);
await hydrateProtectedFileImages(renderRoot, undefined, props.kbId);
const images = renderRoot?.querySelectorAll?.('img.markdown-image') as NodeListOf<HTMLImageElement> | undefined;
if (images) {
images.forEach(async item => {
+10 -1
View File
@@ -430,6 +430,7 @@ function applyHydratedProtectedImage(root: ParentNode, sourceURL: string, blobUR
export async function hydrateProtectedFileImages(
root: ParentNode | null | undefined,
embed?: { channelId: string; token: string },
kbId?: string,
): Promise<void> {
if (!root || typeof window === 'undefined') {
return;
@@ -466,9 +467,16 @@ export async function hydrateProtectedFileImages(
img.dataset.authHydrated = '1';
const isProviderScheme = isProviderFileURL(sourceURL);
// When a KB context is known, route through the KB-scoped proxy. It is
// authorized via RequireKBAccess (own / org-shared / agent-visible) and
// serves objects owned by the KB's source tenant — so images in a shared
// KB (local://<owner-tenant>/...) load for the borrowing tenant, which the
// tenant-scoped /files route rejects as a cross-tenant path.
const fileProxyBase = embed
? `/api/v1/embed/${embed.channelId}/files`
: '/files';
: kbId
? `/api/v1/knowledge-bases/${encodeURIComponent(kbId)}/files`
: '/files';
const requestURL = isProviderScheme
? `${fileProxyBase}?${new URLSearchParams({ file_path: sourceURL }).toString()}`
: sourceURL;
@@ -476,6 +484,7 @@ export async function hydrateProtectedFileImages(
const isProxyRequest =
requestURL.includes('file_path=') &&
(requestURL.startsWith('/files?') ||
/^\/api\/v1\/knowledge-bases\/[^/]+\/files\?/.test(requestURL) ||
/^\/api\/v1\/embed\/[^/]+\/files\?/.test(requestURL));
if (!isProxyRequest) {
img.dataset.authHydrated = '0';
@@ -2291,7 +2291,7 @@ async function createNewSession(value: string): Promise<void> {
</template>
<!-- DocContent drawer (shared by documents tab and wiki source refs) -->
<DocContent ref="docContentRef" :visible="isCardDetails" :details="details" :canEditKB="canEdit"
<DocContent ref="docContentRef" :visible="isCardDetails" :details="details" :canEditKB="canEdit" :kbId="kbId"
@closeDoc="closeDoc" @getDoc="getDoc">
</DocContent>
</div>
@@ -1385,7 +1385,7 @@ function closeImagePreview() {
watch(graphDrawerContent, async () => {
await nextTick()
if (drawerBodyRef.value) {
await hydrateProtectedFileImages(drawerBodyRef.value)
await hydrateProtectedFileImages(drawerBodyRef.value, undefined, props.knowledgeBaseId)
}
})
@@ -1896,7 +1896,7 @@ const indexHasMore = computed(() => {
watch(renderedContent, async () => {
await nextTick()
if (readerBodyRef.value) {
await hydrateProtectedFileImages(readerBodyRef.value)
await hydrateProtectedFileImages(readerBodyRef.value, undefined, props.knowledgeBaseId)
}
})
@@ -1906,7 +1906,7 @@ watch(renderedContent, async () => {
watch(renderedIndexMarkdown, async () => {
await nextTick()
if (indexBodyRef.value) {
await hydrateProtectedFileImages(indexBodyRef.value)
await hydrateProtectedFileImages(indexBodyRef.value, undefined, props.knowledgeBaseId)
}
})
@@ -4449,7 +4449,7 @@ watch(() => props.view, (v) => {
} else if (v === 'browser') {
nextTick(async () => {
if (readerBodyRef.value && renderedContent.value) {
await hydrateProtectedFileImages(readerBodyRef.value)
await hydrateProtectedFileImages(readerBodyRef.value, undefined, props.knowledgeBaseId)
}
})
}
+140
View File
@@ -213,6 +213,10 @@ func NewRouter(params RouterParams) *gin.Engine {
RegisterTenantRoutes(v1, params.TenantHandler, params.TenantMemberHandler, params.TenantInvitationHandler, params.AuditLogHandler, rbacGuards)
RegisterMyInvitationRoutes(v1, params.TenantInvitationHandler)
RegisterKnowledgeBaseRoutes(v1, params.KBHandler, rbacGuards)
// KB-scoped image proxy: lets tenants render images embedded in
// org-shared / agent-visible KB content, which the tenant-scoped
// /files route cannot serve because it enforces same-tenant paths.
serveKBScopedFiles(v1, rbacGuards, params.TenantService, params.FileService)
RegisterKnowledgeTagRoutes(v1, params.TagHandler, rbacGuards)
RegisterKnowledgeRoutes(v1, params.KnowledgeHandler, rbacGuards)
RegisterFAQRoutes(v1, params.FAQHandler, rbacGuards)
@@ -1569,6 +1573,142 @@ func serveFiles(r getRouteRegistrar, globalFileService interfaces.FileService) {
r.GET("/files", middleware.DenyAPIKeyPrincipal(), newFileServeHandler(globalFileService))
}
// serveKBScopedFiles registers the KB-scoped file proxy used to render images
// embedded in a knowledge base's content (chunks / wiki pages). Unlike the
// tenant-scoped /files route — which enforces file_path.tenant == caller.tenant
// and therefore cannot serve objects owned by another tenant — this route is
// gated by RequireKBAccess. That guard resolves org-shared / agent-visible KBs
// and rewrites the request context's tenant ID to the KB's *owner* (source)
// tenant, so images stored under the owner tenant (local://<owner>/exports/...)
// become reachable by tenants that legitimately share the KB, while still
// enforcing that the requested path belongs to that owner tenant.
//
// Route:
// - GET /api/v1/knowledge-bases/:id/files?file_path=<provider://...>
func serveKBScopedFiles(
r *gin.RouterGroup,
g *rbacGuards,
tenantService interfaces.TenantService,
globalFileService interfaces.FileService,
) {
logger.Infof(context.Background(), "[Router] Serving KB-scoped files from /knowledge-bases/:id/files")
// API keys are denied outright (as on /files): a signed URL's tenant/KB
// scope cannot authorize serving an arbitrary file_path under the owner
// tenant, and this route deliberately crosses the caller's own tenant.
r.GET("/knowledge-bases/:id/files",
middleware.DenyAPIKeyPrincipal(),
g.Viewer(),
g.KBAccessRead("id"),
newKBScopedFileServeHandler(tenantService, globalFileService),
)
}
// newKBScopedFileServeHandler builds the handler backing serveKBScopedFiles.
// The effective (owner) tenant is taken from the request context, which
// RequireKBAccess has already rewritten to the KB's source tenant. The owner
// tenant's storage config is loaded via TenantService so the file is fetched
// from the backend that actually holds it — the caller's own storage config is
// irrelevant here.
func newKBScopedFileServeHandler(
tenantService interfaces.TenantService,
globalFileService interfaces.FileService,
) gin.HandlerFunc {
baseDir := os.Getenv("LOCAL_STORAGE_BASE_DIR")
if baseDir == "" {
baseDir = "/data/files"
}
absDir, _ := filepath.Abs(baseDir)
return func(c *gin.Context) {
ctx := c.Request.Context()
filePath := strings.TrimSpace(c.Query("file_path"))
if filePath == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing required parameter: file_path"})
return
}
if strings.Contains(filePath, "..") {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file path"})
return
}
// RequireKBAccess rewrote the request context tenant ID to the KB's
// owner (source) tenant for shared KBs; for own KBs it equals the
// caller's tenant. Either way it is the tenant that owns this KB's
// storage objects, so the requested path must belong to it.
ownerTenantID, ok := types.TenantIDFromContext(ctx)
if !ok || ownerTenantID == 0 {
c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized: tenant context missing"})
return
}
if err := secutils.ValidateStoragePathTenant(filePath, ownerTenantID); err != nil {
logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files denied path not owned by KB tenant: owner_tenant_id=%d file_path=%q err=%v",
ownerTenantID, filePath, err)
c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: file path not accessible"})
return
}
tenant, err := tenantService.GetTenantByID(ctx, ownerTenantID)
if err != nil || tenant == nil {
logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files owner tenant lookup failed: owner_tenant_id=%d err=%v",
ownerTenantID, err)
c.Status(http.StatusNotFound)
return
}
provider := types.ParseProviderScheme(filePath)
var (
fileSvc interfaces.FileService
resolvedProvider string
)
if tenant.StorageEngineConfig != nil {
fileSvc, resolvedProvider, err = filesvc.NewFileServiceFromStorageConfig(provider, tenant.StorageEngineConfig, absDir)
} else {
err = http.ErrMissingFile
}
if err != nil {
globalStorageType := strings.ToLower(strings.TrimSpace(os.Getenv("STORAGE_TYPE")))
if globalStorageType == "" {
globalStorageType = "local"
}
if provider == globalStorageType && globalFileService != nil {
fileSvc = globalFileService
resolvedProvider = globalStorageType
} else {
logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files resolve file service failed: owner_tenant_id=%d provider=%s global_storage_type=%s err=%v",
ownerTenantID, provider, globalStorageType, err)
c.Status(http.StatusBadRequest)
return
}
}
reader, err := fileSvc.GetFile(ctx, filePath)
if err != nil {
logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files get file failed: owner_tenant_id=%d provider=%s path=%q err=%v",
ownerTenantID, resolvedProvider, filePath, err)
c.Status(http.StatusNotFound)
return
}
defer reader.Close()
contentType, inline := secutils.SafeContentTypeByFilename(filePath)
c.Header("Content-Type", contentType)
c.Header("X-Content-Type-Options", "nosniff")
if !inline {
c.Header("Content-Disposition", "attachment")
}
// Cross-tenant shared content — keep it private so shared proxies /
// CDNs do not cache one tenant's view for another.
c.Header("Cache-Control", "private, max-age=86400")
c.Status(http.StatusOK)
if _, err := io.Copy(c.Writer, reader); err != nil {
logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files write response failed: %v", err)
}
}
}
// servePresignedFiles serves files via HMAC-signed URLs without requiring authentication.
// This is used by IM channels to serve images that are embedded in bot replies.
//
+105
View File
@@ -179,6 +179,111 @@ func TestServeFilesRejectsAPIKeyPrincipal(t *testing.T) {
}
}
// newKBScopedFilesTestEngine wires newKBScopedFileServeHandler behind a
// middleware that injects effectiveTenantID into the request context, mirroring
// what RequireKBAccess does after resolving an org-shared KB to its source
// tenant. This lets the handler be exercised without the full RBAC stack.
func newKBScopedFilesTestEngine(
effectiveTenantID uint64,
tenantSvc interfaces.TenantService,
global interfaces.FileService,
) *gin.Engine {
engine := gin.New()
engine.GET("/knowledge-bases/:id/files",
func(c *gin.Context) {
ctx := context.WithValue(c.Request.Context(), types.TenantIDContextKey, effectiveTenantID)
c.Request = c.Request.WithContext(ctx)
c.Next()
},
newKBScopedFileServeHandler(tenantSvc, global),
)
return engine
}
// A tenant whose owner-tenant (10008) storage objects are requested by a
// borrowing tenant via a shared KB: the effective tenant in context is the
// owner, so the path validates and the file is served.
func TestKBScopedFilesServesOwnerTenantPath(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("STORAGE_TYPE", "local")
const ownerTenantID = uint64(10008)
var requestedPath string
engine := newKBScopedFilesTestEngine(
ownerTenantID,
&stubTenantService{get: func(_ context.Context, id uint64) (*types.Tenant, error) {
return &types.Tenant{ID: id}, nil
}},
&stubFileService{getFile: func(_ context.Context, filePath string) (io.ReadCloser, error) {
requestedPath = filePath
return io.NopCloser(strings.NewReader("shared-body")), nil
}},
)
filePath := "local://10008/exports/img.jpg"
req := httptest.NewRequest(http.MethodGet, "/knowledge-bases/kb-1/files?file_path="+url.QueryEscape(filePath), nil)
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, req)
if got, want := recorder.Code, http.StatusOK; got != want {
t.Fatalf("status = %d, want %d body=%s", got, want, recorder.Body.String())
}
if requestedPath != filePath {
t.Fatalf("requested path = %q, want %q", requestedPath, filePath)
}
if body := recorder.Body.String(); body != "shared-body" {
t.Fatalf("body = %q, want %q", body, "shared-body")
}
}
// The path must belong to the effective (owner) tenant. A path pointing at a
// different tenant than the resolved KB owner is still rejected, so the guard
// cannot be used to reach arbitrary tenants' files.
func TestKBScopedFilesRejectsPathNotOwnedByKBTenant(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("STORAGE_TYPE", "local")
const ownerTenantID = uint64(10008)
engine := newKBScopedFilesTestEngine(
ownerTenantID,
&stubTenantService{get: func(_ context.Context, id uint64) (*types.Tenant, error) {
t.Fatalf("GetTenantByID should not be called for mismatched path, got %d", id)
return nil, nil
}},
&stubFileService{getFile: func(_ context.Context, filePath string) (io.ReadCloser, error) {
t.Fatalf("GetFile should not be called for mismatched path, got %q", filePath)
return nil, nil
}},
)
req := httptest.NewRequest(http.MethodGet,
"/knowledge-bases/kb-1/files?file_path="+url.QueryEscape("local://9999/exports/other.jpg"), nil)
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, req)
if got, want := recorder.Code, http.StatusForbidden; got != want {
t.Fatalf("status = %d, want %d", got, want)
}
}
func TestKBScopedFilesRequiresFilePath(t *testing.T) {
gin.SetMode(gin.TestMode)
engine := newKBScopedFilesTestEngine(
10008,
&stubTenantService{},
&stubFileService{},
)
req := httptest.NewRequest(http.MethodGet, "/knowledge-bases/kb-1/files", nil)
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, req)
if got, want := recorder.Code, http.StatusBadRequest; got != want {
t.Fatalf("status = %d, want %d", got, want)
}
}
func TestServeFilesForcesActiveContentDownload(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("STORAGE_TYPE", "local")