Skip to content

The open alternative to Salesforce, designed for AI.

fix: cap the SVG size that file upload completion will sanitize (#25340)

Félix Malfait47dc7202018e
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts
index 1b7cbc412f4..c4494c71417 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.resolver.ts
@@ -53,6 +53,7 @@ import { PublicEndpointGuard } from 'src/engine/guards/public-endpoint.guard';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { StreamSizeExceededError } from 'src/utils/stream-size-exceeded-error';
import { streamToBuffer } from 'src/utils/stream-to-buffer';
import { ApplicationRegistrationVariableDTO } from 'src/engine/core-modules/application/application-registration-variable/dtos/application-registration-variable.dto';
import {
@@ -277,10 +278,7 @@ export class ApplicationRegistrationResolver {
ownerWorkspaceId: workspaceId,
});
} catch (error) {
- if (
- error instanceof Error &&
- error.message.includes('maximum allowed size')
- ) {
+ if (error instanceof StreamSizeExceededError) {
throw new ApplicationRegistrationException(
`Tarball exceeds maximum size of ${maxSize} bytes`,
ApplicationRegistrationExceptionCode.INVALID_INPUT,
diff --git a/packages/twenty-server/src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant.ts b/packages/twenty-server/src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant.ts
new file mode 100644
index 00000000000..8eca45c1d24
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant.ts
@@ -0,0 +1,5 @@
+// DOMPurify needs the whole SVG as a string plus a JSDOM tree, so the peak
+// heap is a large multiple of the file. Anything bigger is refused rather
+// than sanitized: node's max string length would throw well below the
+// direct upload cap anyway.
+export const MAX_SANITIZABLE_SVG_BYTES = 3 * 1024 * 1024;
diff --git a/packages/twenty-server/src/engine/core-modules/file/file-upload/services/__tests__/file-upload-completion.service.spec.ts b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/__tests__/file-upload-completion.service.spec.ts
new file mode 100644
index 00000000000..0e8e25e3f6d
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/__tests__/file-upload-completion.service.spec.ts
@@ -0,0 +1,150 @@
+import { Readable } from 'stream';
+
+import { FileFolder } from 'twenty-shared/types';
+
+import { type FileStorageService } from 'src/engine/core-modules/file-storage/services/file-storage.service';
+import { type FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { MAX_SANITIZABLE_SVG_BYTES } from 'src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant';
+import { FileUploadExceptionCode } from 'src/engine/core-modules/file/file-upload/file-upload.exception';
+import { FileUploadCompletionService } from 'src/engine/core-modules/file/file-upload/services/file-upload-completion.service';
+import { FILE_STATUS } from 'src/engine/core-modules/file/types/file-status.types';
+import { type WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+
+describe('FileUploadCompletionService.completeUploadedFile', () => {
+ const workspaceId = '20202020-0000-4000-8000-000000000001';
+ const fileId = '20202020-0000-4000-8000-000000000002';
+
+ const svgContent =
+ '<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>';
+ const pngContent = Buffer.from([
+ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+ 0x49, 0x48, 0x44, 0x52,
+ ]);
+
+ let fileStorageService: jest.Mocked<FileStorageService>;
+ let fileRepository: jest.Mocked<WorkspaceScopedRepository<FileEntity>>;
+
+ const buildStorageLocation = (ext: string) => ({
+ fileFolder: FileFolder.FilesField,
+ applicationUniversalIdentifier: 'application-universal-identifier',
+ workspaceId,
+ resourcePath: `${fileId}.${ext}`,
+ });
+
+ const buildFile = (ext: string, size: number) =>
+ ({
+ id: fileId,
+ path: `${FileFolder.FilesField}/${fileId}.${ext}`,
+ size,
+ status: FILE_STATUS.PENDING,
+ mimeType: 'application/octet-stream',
+ createdAt: new Date(),
+ }) as FileEntity;
+
+ const buildService = () =>
+ new FileUploadCompletionService(fileStorageService, fileRepository);
+
+ beforeEach(() => {
+ fileStorageService = {
+ getFileMetadata: jest.fn(),
+ readFilePrefix: jest.fn().mockResolvedValue(Buffer.from(svgContent)),
+ readFile: jest
+ .fn()
+ .mockImplementation(async () => Readable.from(Buffer.from(svgContent))),
+ writeFileStream: jest.fn().mockResolvedValue(undefined),
+ } as unknown as jest.Mocked<FileStorageService>;
+
+ fileRepository = {
+ update: jest.fn().mockResolvedValue(undefined),
+ } as unknown as jest.Mocked<WorkspaceScopedRepository<FileEntity>>;
+ });
+
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('should refuse an SVG larger than the sanitizable limit without reading it', async () => {
+ const size = MAX_SANITIZABLE_SVG_BYTES + 1;
+
+ fileStorageService.getFileMetadata.mockResolvedValue({ size });
+
+ await expect(
+ buildService().completeUploadedFile({
+ workspaceId,
+ file: buildFile('svg', size),
+ storageLocation: buildStorageLocation('svg'),
+ }),
+ ).rejects.toMatchObject({
+ code: FileUploadExceptionCode.FILE_TOO_LARGE,
+ });
+
+ expect(fileStorageService.readFile).not.toHaveBeenCalled();
+ expect(fileRepository.update).not.toHaveBeenCalled();
+ });
+
+ it('should report an oversized read as FILE_TOO_LARGE when storage understated the size', async () => {
+ const declaredSize = 1024;
+
+ fileStorageService.getFileMetadata.mockResolvedValue({
+ size: declaredSize,
+ });
+ fileStorageService.readFile.mockResolvedValue(
+ Readable.from(Buffer.alloc(MAX_SANITIZABLE_SVG_BYTES + 1)),
+ );
+
+ await expect(
+ buildService().completeUploadedFile({
+ workspaceId,
+ file: buildFile('svg', declaredSize),
+ storageLocation: buildStorageLocation('svg'),
+ }),
+ ).rejects.toMatchObject({
+ code: FileUploadExceptionCode.FILE_TOO_LARGE,
+ });
+
+ expect(fileRepository.update).not.toHaveBeenCalled();
+ });
+
+ it('should sanitize an SVG within the limit and store its new size', async () => {
+ const size = Buffer.byteLength(svgContent);
+
+ fileStorageService.getFileMetadata.mockResolvedValue({ size });
+
+ const completedFile = await buildService().completeUploadedFile({
+ workspaceId,
+ file: buildFile('svg', size),
+ storageLocation: buildStorageLocation('svg'),
+ });
+
+ expect(completedFile.mimeType).toBe('image/svg+xml');
+ expect(completedFile.size).toBeLessThan(size);
+ expect(fileStorageService.writeFileStream).toHaveBeenCalledTimes(1);
+ expect(fileRepository.update).toHaveBeenCalledWith(
+ workspaceId,
+ { id: fileId },
+ expect.objectContaining({
+ status: FILE_STATUS.UPLOADED,
+ mimeType: 'image/svg+xml',
+ size: completedFile.size,
+ }),
+ );
+ });
+
+ it('should not read a file that does not need sanitizing', async () => {
+ const size = pngContent.length;
+
+ fileStorageService.getFileMetadata.mockResolvedValue({ size });
+ fileStorageService.readFilePrefix.mockResolvedValue(pngContent);
+
+ const completedFile = await buildService().completeUploadedFile({
+ workspaceId,
+ file: buildFile('png', size),
+ storageLocation: buildStorageLocation('png'),
+ });
+
+ expect(completedFile.mimeType).toBe('image/png');
+ expect(completedFile.size).toBe(size);
+ expect(fileStorageService.readFile).not.toHaveBeenCalled();
+ expect(fileStorageService.writeFileStream).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/file/file-upload/services/__tests__/file-upload.service.create-file-upload.spec.ts b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/__tests__/file-upload.service.create-file-upload.spec.ts
new file mode 100644
index 00000000000..1a04734588b
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/__tests__/file-upload.service.create-file-upload.spec.ts
@@ -0,0 +1,52 @@
+import { FileFolder } from 'twenty-shared/types';
+
+import { MAX_SANITIZABLE_SVG_BYTES } from 'src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant';
+import { FileUploadExceptionCode } from 'src/engine/core-modules/file/file-upload/file-upload.exception';
+import { FileUploadService } from 'src/engine/core-modules/file/file-upload/services/file-upload.service';
+
+describe('FileUploadService.createFileUpload', () => {
+ const workspaceId = '20202020-0000-4000-8000-000000000001';
+
+ // The oversized SVG guard rejects before reaching any collaborator.
+ const buildService = () =>
+ new FileUploadService(
+ {} as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ );
+
+ const createUpload = (filename: string, size: number) =>
+ buildService().createFileUpload({
+ workspaceId,
+ filename,
+ size,
+ fileFolder: FileFolder.FilesField,
+ fieldMetadataId: '20202020-0000-4000-8000-000000000002',
+ });
+
+ it.each(['logo.svg', 'logo.SVG', 'logo.Svg'])(
+ 'should refuse an oversized %s before handing out an upload target',
+ async (filename) => {
+ await expect(
+ createUpload(filename, MAX_SANITIZABLE_SVG_BYTES + 1),
+ ).rejects.toMatchObject({
+ code: FileUploadExceptionCode.FILE_TOO_LARGE,
+ });
+ },
+ );
+
+ it('should not refuse an SVG within the limit', async () => {
+ // Reaching a collaborator means the guard let it through, which is what
+ // this asserts: the empty mocks make that surface as a TypeError.
+ await expect(
+ createUpload('logo.svg', MAX_SANITIZABLE_SVG_BYTES),
+ ).rejects.not.toMatchObject({
+ code: FileUploadExceptionCode.FILE_TOO_LARGE,
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload-completion.service.ts b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload-completion.service.ts
index 29902cd4cb9..23f23649e5b 100644
--- a/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload-completion.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload-completion.service.ts
@@ -9,11 +9,13 @@ import { FileStorageService } from 'src/engine/core-modules/file-storage/service
import { FileDTO } from 'src/engine/core-modules/file/dtos/file.dto';
import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
import { FILE_CONTENT_SNIFF_BYTE_COUNT } from 'src/engine/core-modules/file/file-upload/constants/file-content-sniff.constant';
+import { MAX_SANITIZABLE_SVG_BYTES } from 'src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant';
import {
FileUploadException,
FileUploadExceptionCode,
} from 'src/engine/core-modules/file/file-upload/file-upload.exception';
import { type BatchFileResult } from 'src/engine/core-modules/file/file-upload/types/batch-file-result.type';
+import { buildSvgTooLargeException } from 'src/engine/core-modules/file/file-upload/utils/build-svg-too-large-exception.util';
import { toBatchErrorMessage } from 'src/engine/core-modules/file/file-upload/utils/to-batch-error-message.util';
import { fileFolderConfigs } from 'src/engine/core-modules/file/interfaces/file-folder.interface';
import { FILE_STATUS } from 'src/engine/core-modules/file/types/file-status.types';
@@ -22,6 +24,7 @@ import { removeFileFolderFromFileEntityPath } from 'src/engine/core-modules/file
import { sanitizeFile } from 'src/engine/core-modules/file/utils/sanitize-file.utils';
import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+import { StreamSizeExceededError } from 'src/utils/stream-size-exceeded-error';
import { streamToBuffer } from 'src/utils/stream-to-buffer';
export type BatchCompleteUploadRequest = {
@@ -199,9 +202,32 @@ export class FileUploadCompletionService {
return size;
}
+ if (size > MAX_SANITIZABLE_SVG_BYTES) {
+ throw buildSvgTooLargeException(
+ `storage reports ${size} bytes, above the ${MAX_SANITIZABLE_SVG_BYTES} byte limit`,
+ );
+ }
+
const stream = await this.fileStorageService.readFile(storageLocation);
+
+ let file: Buffer;
+
+ try {
+ file = await streamToBuffer(stream, MAX_SANITIZABLE_SVG_BYTES);
+ } catch (error) {
+ if (error instanceof StreamSizeExceededError) {
+ // Deliberately does not quote `size`: storage understated it, so
+ // repeating it here would contradict the failure being reported.
+ throw buildSvgTooLargeException(
+ `content exceeds the ${MAX_SANITIZABLE_SVG_BYTES} byte limit`,
+ );
+ }
+
+ throw error;
+ }
+
const sanitizedFile = sanitizeFile({
- file: await streamToBuffer(stream),
+ file,
ext: 'svg',
mimeType,
});
diff --git a/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload.service.ts b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload.service.ts
index 000e5e0fc3b..27006f18554 100644
--- a/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/file/file-upload/services/file-upload.service.ts
@@ -19,6 +19,7 @@ import { FileStorageService } from 'src/engine/core-modules/file-storage/service
import { FileWithSignedUrlDTO } from 'src/engine/core-modules/file/dtos/file-with-sign-url.dto';
import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
import { COMPLETE_FILE_UPLOAD_DEADLINE_MS } from 'src/engine/core-modules/file/file-upload/constants/complete-file-upload-deadline.constant';
+import { MAX_SANITIZABLE_SVG_BYTES } from 'src/engine/core-modules/file/file-upload/constants/max-sanitizable-svg-size.constant';
import { FileUploadTargetDTO } from 'src/engine/core-modules/file/file-upload/dtos/file-upload-target.dto';
import {
FileUploadException,
@@ -26,6 +27,7 @@ import {
} from 'src/engine/core-modules/file/file-upload/file-upload.exception';
import { FileUploadCompletionService } from 'src/engine/core-modules/file/file-upload/services/file-upload-completion.service';
import { FileUploadTargetService } from 'src/engine/core-modules/file/file-upload/services/file-upload-target.service';
+import { buildSvgTooLargeException } from 'src/engine/core-modules/file/file-upload/utils/build-svg-too-large-exception.util';
import { FileUrlService } from 'src/engine/core-modules/file/file-url/file-url.service';
import { FILE_STATUS } from 'src/engine/core-modules/file/types/file-status.types';
import { buildFileInfo } from 'src/engine/core-modules/file/utils/build-file-info.utils';
@@ -103,6 +105,16 @@ export class FileUploadService {
}
const { ext } = buildFileInfo(filename);
+
+ // Completion refuses to sanitize an SVG this big, so reject before the
+ // client transfers it. The declared extension is a client claim, which
+ // only makes this a shortcut: the sniffed check at completion decides.
+ if (ext.toLowerCase() === 'svg' && size > MAX_SANITIZABLE_SVG_BYTES) {
+ throw buildSvgTooLargeException(
+ `declared size ${size} exceeds the ${MAX_SANITIZABLE_SVG_BYTES} byte limit`,
+ );
+ }
+
const mimeType = 'application/octet-stream';
const fileId = v4();
diff --git a/packages/twenty-server/src/engine/core-modules/file/file-upload/utils/build-svg-too-large-exception.util.ts b/packages/twenty-server/src/engine/core-modules/file/file-upload/utils/build-svg-too-large-exception.util.ts
new file mode 100644
index 00000000000..2a08b1ac245
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/file/file-upload/utils/build-svg-too-large-exception.util.ts
@@ -0,0 +1,17 @@
+import { msg } from '@lingui/core/macro';
+
+import {
+ FileUploadException,
+ FileUploadExceptionCode,
+} from 'src/engine/core-modules/file/file-upload/file-upload.exception';
+
+export const buildSvgTooLargeException = (
+ detail: string,
+): FileUploadException =>
+ new FileUploadException(
+ `SVG cannot be sanitized: ${detail}`,
+ FileUploadExceptionCode.FILE_TOO_LARGE,
+ {
+ userFriendlyMessage: msg`This SVG is too large to be processed.`,
+ },
+ );
diff --git a/packages/twenty-server/src/utils/stream-size-exceeded-error.ts b/packages/twenty-server/src/utils/stream-size-exceeded-error.ts
new file mode 100644
index 00000000000..66dc569a82e
--- /dev/null
+++ b/packages/twenty-server/src/utils/stream-size-exceeded-error.ts
@@ -0,0 +1,8 @@
+// Callers that cap a read need to tell "too big" apart from a storage failure
+// without matching on a message, so they can map it to their own domain error.
+export class StreamSizeExceededError extends Error {
+ constructor(maxSizeBytes: number) {
+ super(`Stream exceeds maximum allowed size of ${maxSizeBytes} bytes`);
+ this.name = 'StreamSizeExceededError';
+ }
+}
diff --git a/packages/twenty-server/src/utils/stream-to-buffer.ts b/packages/twenty-server/src/utils/stream-to-buffer.ts
index 3479f63de23..8b59e608b08 100644
--- a/packages/twenty-server/src/utils/stream-to-buffer.ts
+++ b/packages/twenty-server/src/utils/stream-to-buffer.ts
@@ -1,5 +1,7 @@
import { type Readable } from 'stream';
+import { StreamSizeExceededError } from 'src/utils/stream-size-exceeded-error';
+
export const streamToBuffer = async (
stream: Readable,
maxSizeBytes?: number,
@@ -37,11 +39,7 @@ export const streamToBuffer = async (
isResolved = true;
cleanup();
stream.destroy();
- reject(
- new Error(
- `Stream exceeds maximum allowed size of ${maxSizeBytes} bytes`,
- ),
- );
+ reject(new StreamSizeExceededError(maxSizeBytes));
return;
}