fix(parsers): bound ODF whitespace expansion and accept absolute OPC targets

An ODF text:s element passed its text:c count straight to String.repeat,
so one tiny element could request a multi-gigabyte allocation. Each run
is now capped at 100 spaces, every emitted piece is charged against a
16 MiB document budget that throws complexity_limit before later parts
are inflated, and both walkers assert the assembled text against the
same ceiling. The line-end trim that followed was quadratic on a long
whitespace run — a document inside the budget could still hang it — so
it is now a linear per-line trimEnd.

OPC relationship targets may be package-absolute (/ppt/slides/slide1.xml);
the PPTX resolver joined them onto the base directory and skipped those
parts. A leading slash now resolves from the package root under the same
ppt/ clamp.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/lib/file-parsers/odf-text.test.ts

@@ -5,7 +5,7 @@ import JSZip, { type JSZipObject } from 'jszip'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { FileParserError } from '@/lib/file-parsers/errors'
 import { extractOpenDocumentText } from '@/lib/file-parsers/odf-text'
-import { MAX_OFFICE_XML_PART_BYTES } from '@/lib/file-parsers/office-text'
+import { MAX_OFFICE_TEXT_BYTES, MAX_OFFICE_XML_PART_BYTES } from '@/lib/file-parsers/office-text'
 
 const NS =
   'xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:presentation="urn:oasis:names:tc:opendocument:xmlns:presentation:1.0" xmlns:dc="http://purl.org/dc/elements/1.1/"'
@@ -104,6 +104,48 @@ describe('extractOpenDocumentText', () => {
     expect(result).toBe('[Table]\n| Out A | Intro In 1 / In 2 / In 3 |\n[/Table]')
   })
 
+  it('caps a text:s run instead of allocating what text:c asks for', async () => {
+    const buffer = await text(`<text:p>A<text:s text:c="1000000000"/>B</text:p>`)
+
+    expect(await extractOpenDocumentText(buffer)).toBe(`A${' '.repeat(100)}B`)
+  })
+
+  it('handles a long whitespace run inside the budget in linear time', async () => {
+    const spaces = '<text:s text:c="100"/>'.repeat(2_000)
+    const buffer = await text(`<text:p>x${spaces}y<text:line-break/>z</text:p>`)
+
+    const started = performance.now()
+    const result = await extractOpenDocumentText(buffer)
+
+    expect(result).toBe(`x${' '.repeat(200_000)}y\nz`)
+    expect(performance.now() - started).toBeLessThan(5_000)
+  }, 60_000)
+
+  it('rejects a document whose expanded text exceeds the ceiling', async () => {
+    const spaces = '<text:s text:c="100"/>'.repeat(Math.ceil(MAX_OFFICE_TEXT_BYTES / 100) + 1)
+    const buffer = await text(`<text:p>x${spaces}y</text:p>`)
+
+    await expect(extractOpenDocumentText(buffer)).rejects.toMatchObject<FileParserError>({
+      code: 'complexity_limit',
+    })
+  })
+
+  it('stops walking at the ceiling before inflating later parts', async () => {
+    const spaces = '<text:s text:c="100"/>'.repeat(Math.ceil(MAX_OFFICE_TEXT_BYTES / 100) + 1)
+    const buffer = await buildOdf(`<office:text><text:p>x${spaces}y</text:p></office:text>`, {
+      'Object 1/content.xml': `<?xml version="1.0"?><office:document-content ${NS}><office:body><office:text><text:p>Embedded</text:p></office:text></office:body></office:document-content>`,
+    })
+    const zip = await JSZip.loadAsync(buffer)
+    const embedded = zip.file('Object 1/content.xml') as JSZipObject
+    const inflate = vi.spyOn(embedded, 'async')
+    vi.spyOn(JSZip, 'loadAsync').mockResolvedValueOnce(zip)
+
+    await expect(extractOpenDocumentText(buffer)).rejects.toMatchObject<FileParserError>({
+      code: 'complexity_limit',
+    })
+    expect(inflate).not.toHaveBeenCalled()
+  })
+
   it('rejects an archive without content.xml as invalid_format', async () => {
     const zip = new JSZip()
     zip.file('mimetype', 'application/vnd.oasis.opendocument.text', { compression: 'STORE' })

apps/sim/lib/file-parsers/odf-text.ts

@@ -1,6 +1,8 @@
 import JSZip from 'jszip'
 import { FileParserError } from '@/lib/file-parsers/errors'
 import {
+  assertTextWithinLimit,
+  chargeTextBudget,
   childElements,
   collapseWhitespace,
   findFirst,
@@ -13,6 +15,8 @@ import {
   readXmlPart,
   TABLE_CLOSE,
   TABLE_OPEN,
+  type TextBudget,
+  trimLineEnds,
   type XmlElement,
 } from '@/lib/file-parsers/office-text'
 import type { FileParseOptions } from '@/lib/file-parsers/types'
@@ -49,6 +53,9 @@ const SKIPPED_PRESENTATION_CLASSES = new Set(['header', 'footer', 'date-time', '
 /** Bounds `table:number-columns-repeated`, which spreadsheets inflate to 1024. */
 const MAX_REPEATED_COLUMNS = 32
 
+/** Bounds one `text:s` run; `text:c` is attacker-controlled and would otherwise size an allocation. */
+const MAX_SPACE_RUN = 100
+
 const MAX_LIST_INDENT = 3
 
 interface WalkState {
@@ -57,10 +64,18 @@ interface WalkState {
   pendingNotes: string[]
   /** Inside a table cell, nested tables flatten to text rather than emitting markers. */
   inCell: boolean
+  /** Shared across the document so cells and note bodies count toward one ceiling. */
+  budget: TextBudget
+}
+
+function newState(budget: TextBudget, inCell = false): WalkState {
+  return { blocks: [], pendingNotes: [], inCell, budget }
 }
 
-function newState(inCell = false): WalkState {
-  return { blocks: [], pendingNotes: [], inCell }
+/** Records a piece of emitted text against the document ceiling before it is kept. */
+function emit(state: WalkState, pieces: string[], text: string): void {
+  chargeTextBudget(state.budget, text.length)
+  pieces.push(text)
 }
 
 function isSkipped(element: XmlElement): boolean {
@@ -80,22 +95,23 @@ function inlineText(element: XmlElement, state: WalkState): string {
   const pieces: string[] = []
   for (const child of element.children) {
     if (child.type === 'text') {
-      pieces.push(child.data)
+      emit(state, pieces, child.data)
       continue
     }
     if (!isXmlElement(child) || isSkipped(child)) continue
 
     switch (child.name) {
       case 'text:s': {
         const count = Number.parseInt(child.attribs['text:c'] ?? '1', 10)
-        pieces.push(' '.repeat(Number.isFinite(count) && count > 0 ? count : 1))
+        const bounded = Number.isFinite(count) && count > 0 ? Math.min(count, MAX_SPACE_RUN) : 1
+        emit(state, pieces, ' '.repeat(bounded))
         break
       }
       case 'text:tab':
-        pieces.push('\t')
+        emit(state, pieces, '\t')
         break
       case 'text:line-break':
-        pieces.push('\n')
+        emit(state, pieces, '\n')
         break
       case 'draw:frame': {
         const image = imageFrameText(child, state)
@@ -106,7 +122,7 @@ function inlineText(element: XmlElement, state: WalkState): string {
         const citation = findFirst(child, 'text:note-citation')
         const body = findFirst(child, 'text:note-body')
         const label = citation ? collapseWhitespace(inlineText(citation, state)) : ''
-        const bodyText = body ? collapseWhitespace(blockText(body)) : ''
+        const bodyText = body ? collapseWhitespace(blockText(body, state.budget)) : ''
         if (label) pieces.push(`[${label}]`)
         if (bodyText) state.pendingNotes.push(label ? `[${label}] ${bodyText}` : bodyText)
         break
@@ -119,8 +135,8 @@ function inlineText(element: XmlElement, state: WalkState): string {
 }
 
 /** Renders a container's block children to a single string, for cells and note bodies. */
-function blockText(container: XmlElement, inCell = false): string {
-  const state = newState(inCell)
+function blockText(container: XmlElement, budget: TextBudget, inCell = false): string {
+  const state = newState(budget, inCell)
   walkChildren(container, state, 0)
   return [...state.blocks, ...state.pendingNotes].join('\n')
 }
@@ -132,9 +148,7 @@ function flushNotes(state: WalkState): void {
 }
 
 function emitParagraph(element: XmlElement, state: WalkState, heading: boolean): void {
-  const text = inlineText(element, state)
-    .replace(/[ \t]+\n/g, '\n')
-    .trim()
+  const text = trimLineEnds(inlineText(element, state)).trim()
   if (text) {
     state.blocks.push(heading ? `\n${text}\n` : text)
   }
@@ -167,8 +181,8 @@ function emitList(list: XmlElement, state: WalkState, depth: number): void {
   }
 }
 
-function cellText(cell: XmlElement): string {
-  return collapseWhitespace(blockText(cell, true))
+function cellText(cell: XmlElement, budget: TextBudget): string {
+  return collapseWhitespace(blockText(cell, budget, true))
 }
 
 function repeatCount(element: XmlElement, attribute: string, cap: number): number {
@@ -179,15 +193,15 @@ function repeatCount(element: XmlElement, attribute: string, cap: number): numbe
   return Math.min(parsed, cap)
 }
 
-function tableRows(container: XmlElement, rows: string[]): void {
+function tableRows(container: XmlElement, rows: string[], state: WalkState): void {
   for (const child of childElements(container)) {
     if (isSkipped(child)) continue
     switch (child.name) {
       case 'table:table-row': {
         const cells: string[] = []
         for (const cell of childElements(child)) {
           if (cell.name !== 'table:table-cell' && cell.name !== 'table:covered-table-cell') continue
-          const text = cellText(cell)
+          const text = cellText(cell, state.budget)
           const repeats = repeatCount(cell, 'table:number-columns-repeated', MAX_REPEATED_COLUMNS)
           for (let i = 0; i < repeats; i++) cells.push(text)
         }
@@ -197,7 +211,7 @@ function tableRows(container: XmlElement, rows: string[]): void {
       case 'table:table-header-rows':
       case 'table:table-rows':
       case 'table:table-row-group':
-        tableRows(child, rows)
+        tableRows(child, rows, state)
         break
       default:
         break
@@ -206,34 +220,34 @@ function tableRows(container: XmlElement, rows: string[]): void {
 }
 
 /** Every non-empty cell of a table in reading order, for a table nested inside a cell. */
-function flattenedCells(container: XmlElement, cells: string[]): void {
+function flattenedCells(container: XmlElement, cells: string[], state: WalkState): void {
   for (const child of childElements(container)) {
     if (isSkipped(child)) continue
     if (child.name === 'table:table-row') {
       for (const cell of childElements(child)) {
         if (cell.name !== 'table:table-cell' && cell.name !== 'table:covered-table-cell') continue
-        const text = cellText(cell)
+        const text = cellText(cell, state.budget)
         if (text) cells.push(text)
       }
     } else if (
       child.name === 'table:table-header-rows' ||
       child.name === 'table:table-rows' ||
       child.name === 'table:table-row-group'
     ) {
-      flattenedCells(child, cells)
+      flattenedCells(child, cells, state)
     }
   }
 }
 
 function emitTable(table: XmlElement, state: WalkState): void {
   if (state.inCell) {
     const cells: string[] = []
-    flattenedCells(table, cells)
+    flattenedCells(table, cells, state)
     if (cells.length > 0) state.blocks.push(cells.join(' / '))
     return
   }
   const rows: string[] = []
-  tableRows(table, rows)
+  tableRows(table, rows, state)
   if (rows.length > 0) {
     state.blocks.push('', TABLE_OPEN, ...rows, TABLE_CLOSE, '')
   }
@@ -251,7 +265,7 @@ function imageFrameText(frame: XmlElement, state: WalkState): string | null {
 }
 
 function emitNotes(notes: XmlElement, state: WalkState): void {
-  const body = collapseWhitespace(blockText(notes))
+  const body = collapseWhitespace(blockText(notes, state.budget))
   if (body) state.blocks.push(NOTES_MARKER, body)
 }
 
@@ -299,11 +313,11 @@ function walkChildren(container: XmlElement, state: WalkState, depth: number): v
   }
 }
 
-function contentBlocks(contentXml: string): string[] {
+function contentBlocks(contentXml: string, budget: TextBudget): string[] {
   const document = parseXml(contentXml)
   const body = findFirst(document, 'office:body')
   if (!body) return []
-  const state = newState()
+  const state = newState(budget)
   walkChildren(body, state, 0)
   flushNotes(state)
   return state.blocks
@@ -321,7 +335,8 @@ function embeddedContentParts(zip: JSZip): string[] {
 /**
  * Extracts structured text from an OpenDocument text or presentation package.
  * The caller must already have applied the archive size guard; each XML part is
- * additionally bounded by {@link readXmlPart}. An archive without `content.xml`
+ * additionally bounded by {@link readXmlPart} and the assembled text by
+ * {@link assertTextWithinLimit}. An archive without `content.xml`
  * is not an OpenDocument file at all and is rejected as `invalid_format`; a
  * present but textless body yields an empty string for the caller to classify.
  */
@@ -339,14 +354,15 @@ export async function extractOpenDocumentText(
     )
   }
 
+  const budget: TextBudget = { used: 0 }
   const sections: string[] = []
   for (const path of [CONTENT_PART, ...embeddedContentParts(zip)]) {
     const xml = await readXmlPart(zip, path)
     options.signal?.throwIfAborted()
     if (xml === null) continue
-    const blocks = contentBlocks(xml)
+    const blocks = contentBlocks(xml, budget)
     if (blocks.length > 0) sections.push(joinBlocks(blocks), '')
   }
 
-  return joinBlocks(sections)
+  return assertTextWithinLimit(joinBlocks(sections))
 }

apps/sim/lib/file-parsers/office-text.ts

@@ -36,6 +36,40 @@ function declaredUncompressedSize(entry: JSZipObject): number | undefined {
   return typeof size === 'number' && Number.isFinite(size) ? size : undefined
 }
 
+/**
+ * Hard ceiling on the text a walker assembles from one document. The part cap
+ * bounds the markup, but ODF whitespace and repeat attributes can expand a
+ * small part many times over, so the output is bounded on its own.
+ */
+export const MAX_OFFICE_TEXT_BYTES = MAX_OFFICE_XML_PART_BYTES
+
+/** Running total of emitted text, shared by every walk state of one document. */
+export interface TextBudget {
+  used: number
+}
+
+export function chargeTextBudget(budget: TextBudget, length: number): void {
+  budget.used += length
+  if (budget.used > MAX_OFFICE_TEXT_BYTES) {
+    throw new FileParserError(
+      'complexity_limit',
+      `Document text exceeds the maximum of ${MAX_OFFICE_TEXT_BYTES} bytes`
+    )
+  }
+}
+
+/** The assembled output must fit the same ceiling once joined. */
+export function assertTextWithinLimit(text: string): string {
+  const bytes = Buffer.byteLength(text, 'utf8')
+  if (bytes > MAX_OFFICE_TEXT_BYTES) {
+    throw new FileParserError(
+      'complexity_limit',
+      `Document text is ${bytes} bytes, above the maximum of ${MAX_OFFICE_TEXT_BYTES} bytes`
+    )
+  }
+  return text
+}
+
 function xmlPartTooLarge(path: string, bytes: number): FileParserError {
   return new FileParserError(
     'complexity_limit',
@@ -104,6 +138,21 @@ export function imageAltText(raw: string | undefined): string | null {
   return `[Image: ${text}]`
 }
 
+/**
+ * Strips trailing spaces and tabs from every line in linear time. The obvious
+ * `/[ \t]+\n/` is quadratic on a long whitespace run — each position scans
+ * the run, fails on the newline, and backtracks — which a document inside the
+ * text budget can still trigger.
+ */
+export function trimLineEnds(text: string): string {
+  return text.includes('\n')
+    ? text
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .join('\n')
+    : text
+}
+
 /** Collapses internal whitespace so a cell or list item occupies a single line. */
 export function collapseWhitespace(text: string): string {
   return text.replace(/\s+/g, ' ').trim()