fix(files): authorize the workspace before resolving a files/ path

Author: waleedlatif1

apps/sim/lib/workspace-files/__integration__/file-path-references.integration.ts

@@ -2,7 +2,7 @@
  * Real PostgreSQL behavior of single-file operations addressed by a `files/…` VFS path instead
  * of an id: the path names exactly one live file in the asserted workspace, never a same-named
  * file in another folder or workspace, a chat upload or an archived file, and authorization is
- * unchanged.
+ * unchanged. A caller who cannot reach the workspace learns nothing about the paths in it.
  */
 import { db } from '@sim/db'
 import { permissions, user, workspace, workspaceFiles } from '@sim/db/schema'
@@ -224,6 +224,27 @@ describe('single-file operations addressed by VFS path', () => {
     expect((await row(ids.rootReport))?.deletedAt).toBeNull()
   })
 
+  it('answers a non-member the same for an ambiguous, a missing and an existing path', async () => {
+    const ambiguous = workspaceFileVfsPath((await describeFile(ids.alikeSingle)).file)
+    const outcomes = await Promise.all(
+      [ambiguous, 'files/missing.csv', 'files/report.csv'].map((path) =>
+        describeFile(path, carol).then(
+          () => null,
+          (error: { code?: string; message?: string }) => ({
+            code: error.code,
+            message: error.message,
+          })
+        )
+      )
+    )
+    expect(outcomes[0]).toMatchObject({ code: 'forbidden' })
+    expect(outcomes[1]).toEqual(outcomes[0])
+    expect(outcomes[2]).toEqual(outcomes[0])
+    await expect(describeFile('files/Docs/../report.csv', carol)).rejects.toMatchObject({
+      code: 'validation',
+    })
+  })
+
   it('rejects a dot-segment path instead of walking out of its folder', async () => {
     await expect(deleteFile('files/Docs/../report.csv')).rejects.toMatchObject({
       code: 'validation',

apps/sim/lib/workspace-files/application/authorized-workspace-file-use-case.ts

@@ -7,6 +7,7 @@ import {
   type WorkspaceFileAuthorizationContext,
   workspaceFileDelegationPolicy,
 } from '@/lib/workspace-files/application/authorization'
+import { authorizeWorkspaceFileVfsPath } from '@/lib/workspace-files/application/file-context'
 
 type AuthorizedWorkspaceFileUseCaseDefinition<
   O extends WorkspaceOperation,
@@ -23,6 +24,10 @@ export function defineAuthorizedWorkspaceFileUseCase<
 >(definition: AuthorizedWorkspaceFileUseCaseDefinition<O, I, C, R>) {
   return defineAuthorizedWorkspaceUseCase({
     ...definition,
+    async resolveContext(args) {
+      await authorizeWorkspaceFileVfsPath(args.principal, definition.operation, args.input)
+      return definition.resolveContext(args)
+    },
     authorizationOptions: { delegation: workspaceFileDelegationPolicy },
   })
 }

apps/sim/lib/workspace-files/application/file-context.ts

@@ -1,14 +1,18 @@
 import type { Principal } from '@sim/auth/principal'
+import { isRecordLike } from '@sim/utils/object'
+import { authorizeWorkspaceOperation, type WorkspaceOperation } from '@/lib/core/application'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import type { DbOrTx } from '@/lib/db/types'
 import {
   type ActiveWorkspaceFileContext,
   getWorkspaceFileByVfsPath,
+  loadActiveWorkspaceContext,
   loadActiveWorkspaceFileContext,
   loadWorkspaceFileLifecycleContext,
   type WorkspaceFileLifecycleContext,
 } from '@/lib/uploads/contexts/workspace/file-manager'
-import { isWorkspaceFileVfsPath, VfsPathError } from '@/lib/vfs/path'
+import { decodeVfsReferenceSegments, isWorkspaceFileVfsPath, VfsPathError } from '@/lib/vfs/path'
+import { WORKSPACE_FILES_DELEGATION_AUDIENCE } from '@/lib/workspace-files/application/authorization'
 import { ownedFileKind } from '@/lib/workspace-files/owned-files'
 import { matchesFileOwner } from '@/lib/workspace-files/ownership'
 
@@ -77,19 +81,54 @@ function requireWorkspaceFileContext<C extends ActiveWorkspaceFileContext>(
   return canonical
 }
 
-/** A path becomes an id first, so the canonical load and every authorization check run unchanged. */
+function invalidVfsPathError(vfsPath: string, error: unknown): unknown {
+  if (!(error instanceof VfsPathError)) return error
+  return new OrchestrationError(
+    'validation',
+    `"${vfsPath}" is not a valid workspace file path: ${error.message}`
+  )
+}
+
+/**
+ * Admits the principal into the asserted workspace before a `files/…` path is looked up by name
+ * there, so nothing the lookup answers (a missing file, two names that display alike) reaches a
+ * caller with no access to that workspace. A malformed path is refused first: deciding that reads
+ * nothing and says nothing about the workspace. Any other input passes untouched. A delegation
+ * scoped to one file is checked once the path names a file, by the use case's own authorization.
+ */
+export async function authorizeWorkspaceFileVfsPath(
+  principal: Principal,
+  operation: WorkspaceOperation,
+  input: unknown
+): Promise<void> {
+  if (!isRecordLike(input)) return
+  const { fileId: vfsPath, assertedWorkspaceId } = input
+  if (typeof vfsPath !== 'string' || !isWorkspaceFileVfsPath(vfsPath)) return
+  if (typeof assertedWorkspaceId !== 'string') return
+  try {
+    decodeVfsReferenceSegments(vfsPath.slice('files/'.length))
+  } catch (error) {
+    throw invalidVfsPathError(vfsPath, error)
+  }
+  const workspace = await loadActiveWorkspaceContext(assertedWorkspaceId)
+  if (!workspace) throw new OrchestrationError('not_found', 'File not found')
+  await authorizeWorkspaceOperation(principal, operation, workspace, {
+    delegation: { audience: WORKSPACE_FILES_DELEGATION_AUDIENCE, isWithinScope: () => true },
+  })
+}
+
+/**
+ * A path becomes an id first, so the canonical load and every authorization check run unchanged.
+ * Use cases reach this only after {@link authorizeWorkspaceFileVfsPath} admitted the caller.
+ */
 async function resolveFileId(input: WorkspaceFileContextInput): Promise<string> {
   if (!isWorkspaceFileVfsPath(input.fileId)) return input.fileId
   if (input.assertedWorkspaceId === undefined) {
     throw new OrchestrationError('not_found', 'File not found')
   }
   const file = await getWorkspaceFileByVfsPath(input.assertedWorkspaceId, input.fileId).catch(
     (error: unknown) => {
-      if (!(error instanceof VfsPathError)) throw error
-      throw new OrchestrationError(
-        'validation',
-        `"${input.fileId}" is not a valid workspace file path: ${error.message}`
-      )
+      throw invalidVfsPathError(input.fileId, error)
     }
   )
   if (!file) throw new OrchestrationError('not_found', 'File not found')