fix(file-parsers): guard .doc uploads against zip-bomb memory exhaustion

DocParser handed the raw upload straight to officeparser and then mammoth,
both of which inflate every ZIP entry into memory before any app-level size
cap applies. The extension is only a routing hint, so a bomb-bearing OOXML
archive renamed to .doc selected the one parser that skipped the guard its
docx/pptx/xlsx siblings all call.

Adds assertOoxmlArchiveWithinLimits to DocParser.parseBuffer, and centrally
in file-parsers parseBuffer so a future parser cannot silently opt out. The
guard reads the central directory's declared sizes without decompressing,
and no-ops for non-ZIP buffers, so legacy OLE .doc files are unaffected.

Author: waleedlatif1

apps/sim/lib/file-parsers/doc-parser.test.ts

@@ -0,0 +1,101 @@
+/**
+ * @vitest-environment node
+ */
+import JSZip from 'jszip'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockParseOfficeAsync, mockExtractRawText } = vi.hoisted(() => ({
+  mockParseOfficeAsync: vi.fn(),
+  mockExtractRawText: vi.fn(),
+}))
+
+vi.mock('officeparser', () => ({ parseOfficeAsync: mockParseOfficeAsync }))
+vi.mock('mammoth', () => ({
+  default: { extractRawText: mockExtractRawText },
+  extractRawText: mockExtractRawText,
+}))
+
+import { DocParser } from '@/lib/file-parsers/doc-parser'
+
+const CENTRAL_DIRECTORY_HEADER_SIGNATURE = 0x02014b50
+
+/**
+ * Build a small OOXML-shaped archive whose central directory *declares* a huge
+ * uncompressed size. The guard reads declared sizes without inflating anything,
+ * so this reproduces a zip bomb's central directory at a few hundred bytes.
+ */
+async function buildDeclaredOversizeArchive(declaredUncompressedBytes: number): Promise<Buffer> {
+  const zip = new JSZip()
+  zip.file('word/document.xml', '<w:document><w:body>A</w:body></w:document>')
+  const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+
+  for (let offset = 0; offset + 28 <= buffer.length; offset++) {
+    if (buffer.readUInt32LE(offset) === CENTRAL_DIRECTORY_HEADER_SIGNATURE) {
+      buffer.writeUInt32LE(declaredUncompressedBytes, offset + 24)
+      return buffer
+    }
+  }
+  throw new Error('No central directory header found in generated archive')
+}
+
+/** A legacy OLE compound-file `.doc` — not a ZIP, so the guard must no-op. */
+function buildLegacyOleDoc(): Buffer {
+  const buffer = Buffer.alloc(512)
+  Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]).copy(buffer, 0)
+  return buffer
+}
+
+describe('DocParser.parseBuffer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('rejects a ZIP-shaped .doc whose declared expanded size exceeds the cap', async () => {
+    const bomb = await buildDeclaredOversizeArchive(2 * 1024 * 1024 * 1024)
+
+    await expect(new DocParser().parseBuffer(bomb)).rejects.toThrow(/exceeds the maximum allowed/)
+  })
+
+  it('rejects the bomb before either decompression library sees the buffer', async () => {
+    const bomb = await buildDeclaredOversizeArchive(2 * 1024 * 1024 * 1024)
+
+    await expect(new DocParser().parseBuffer(bomb)).rejects.toThrow()
+    expect(mockParseOfficeAsync).not.toHaveBeenCalled()
+    expect(mockExtractRawText).not.toHaveBeenCalled()
+  })
+
+  it('rejects a ZIP-shaped .doc whose central directory cannot be parsed', async () => {
+    const buffer = Buffer.alloc(64)
+    buffer.writeUInt32LE(0x04034b50, 0)
+
+    await expect(new DocParser().parseBuffer(buffer)).rejects.toThrow(
+      /refusing to parse an unverifiable ZIP-shaped archive/
+    )
+    expect(mockParseOfficeAsync).not.toHaveBeenCalled()
+  })
+
+  it('still parses a well-formed OOXML archive renamed to .doc', async () => {
+    const zip = new JSZip()
+    zip.file('word/document.xml', '<w:document><w:body>hello</w:body></w:document>')
+    const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+    mockParseOfficeAsync.mockResolvedValue('hello')
+
+    const result = await new DocParser().parseBuffer(buffer)
+
+    expect(result.content).toBe('hello')
+    expect(result.metadata.extractionMethod).toBe('officeparser')
+  })
+
+  it('no-ops the guard for a legacy OLE .doc and parses it', async () => {
+    mockParseOfficeAsync.mockResolvedValue('legacy doc text')
+
+    const result = await new DocParser().parseBuffer(buildLegacyOleDoc())
+
+    expect(mockParseOfficeAsync).toHaveBeenCalledOnce()
+    expect(result.content).toBe('legacy doc text')
+  })
+
+  it('rejects an empty buffer', async () => {
+    await expect(new DocParser().parseBuffer(Buffer.alloc(0))).rejects.toThrow('Empty buffer')
+  })
+})

apps/sim/lib/file-parsers/doc-parser.ts

@@ -3,6 +3,7 @@ import { readFile } from 'fs/promises'
 import { createLogger } from '@sim/logger'
 import type { FileParseResult, FileParser } from '@/lib/file-parsers/types'
 import { sanitizeTextForUTF8 } from '@/lib/file-parsers/utils'
+import { assertOoxmlArchiveWithinLimits } from '@/lib/file-parsers/zip-guard'
 
 const logger = createLogger('DocParser')
 
@@ -25,12 +26,20 @@ export class DocParser implements FileParser {
     }
   }
 
+  /**
+   * A `.doc` upload is only routed here by extension — `officeparser` and
+   * `mammoth` both accept an OOXML/ZIP container regardless of its name, so the
+   * zip-bomb guard must run here exactly as it does in the docx/pptx/xlsx
+   * parsers. It no-ops for genuine legacy OLE `.doc` buffers.
+   */
   async parseBuffer(buffer: Buffer): Promise<FileParseResult> {
     try {
       if (!buffer || buffer.length === 0) {
         throw new Error('Empty buffer provided')
       }
 
+      assertOoxmlArchiveWithinLimits(buffer)
+
       try {
         const officeParser = await import('officeparser')
         const result = await officeParser.parseOfficeAsync(buffer)

apps/sim/lib/file-parsers/index.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'fs'
 import path from 'path'
 import { createLogger } from '@sim/logger'
 import type { FileParseResult, FileParser, SupportedFileType } from '@/lib/file-parsers/types'
+import { assertOoxmlArchiveWithinLimits } from '@/lib/file-parsers/zip-guard'
 
 const logger = createLogger('FileParser')
 
@@ -168,6 +169,11 @@ export async function parseFile(filePath: string): Promise<FileParseResult> {
  * @param buffer Buffer containing the file data
  * @param extension File extension without the dot (e.g., 'pdf', 'csv')
  * @returns Parsed content and metadata
+ *
+ * The zip-bomb guard runs here for every extension, not just the OOXML ones:
+ * the extension is an attacker-controlled routing hint, and the guard no-ops
+ * for buffers that are not ZIP archives. Individual parsers still call it so a
+ * direct `parser.parseBuffer` caller is covered too.
  */
 export async function parseBuffer(buffer: Buffer, extension: string): Promise<FileParseResult> {
   try {
@@ -179,6 +185,8 @@ export async function parseBuffer(buffer: Buffer, extension: string): Promise<Fi
       throw new Error('No file extension provided')
     }
 
+    assertOoxmlArchiveWithinLimits(buffer)
+
     const normalizedExtension = extension.toLowerCase()
     logger.info('Attempting to parse buffer with extension:', normalizedExtension)