harden YAML guard: charge keys + escaping, bound stack, fail closed

Addresses review findings on the alias-expansion guard:

- Charge object keys, not just values. JSON.stringify re-emits every key on
  each alias expansion, so an aliased object with a long key amplified without
  being counted. Keys are now charged against the size cap.
- Compute the exact JSON-escaped string length (quotes, backslashes, control
  chars) instead of a flat multiplier. Plain text is charged its true 1:1 size
  (no false rejection of large legitimate documents) while escape-heavy strings
  are charged their real, larger cost (no cap bypass).
- Count each node as it is enqueued and only push container nodes onto the
  traversal stack. A pathologically wide fan-out now trips a cap during the
  enqueue loop instead of first materializing millions of stack entries and
  exhausting memory inside the guard itself.
- Fail closed in POST /api/files/parse: a YamlComplexityError rejection is now
  re-thrown (mirroring isPayloadSizeLimitError) rather than silently falling
  back to storing the crafted document as raw text.

Author: waleedlatif1

apps/sim/app/api/files/parse/route.ts

@@ -13,6 +13,7 @@ import { checkInternalAuth } from '@/lib/auth/hybrid'
 import { sanitizeUrlForLog } from '@/lib/core/utils/logging'
 import { assertKnownSizeWithinLimit, isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
 import { isSupportedFileType, parseFile } from '@/lib/file-parsers'
+import { isYamlComplexityError } from '@/lib/file-parsers/yaml-parser'
 import { isUsingCloudStorage, StorageService } from '@/lib/uploads'
 import { uploadExecutionFile } from '@/lib/uploads/contexts/execution'
 import {
@@ -1043,6 +1044,9 @@ async function handleGenericTextBuffer(
       }
     } catch (parserError) {
       if (isPayloadSizeLimitError(parserError)) throw parserError
+      // Fail closed on a resource-exhaustion rejection instead of silently
+      // storing the crafted document as raw text.
+      if (isYamlComplexityError(parserError)) throw parserError
 
       logger.warn('Specialized parser failed, falling back to generic parsing:', parserError)
     }

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

@@ -50,6 +50,22 @@ describe('parseYAMLBuffer', () => {
     await expect(parseYAMLBuffer(Buffer.from(bomb))).rejects.toBeInstanceOf(YamlComplexityError)
   })
 
+  it('rejects a key-amplification bomb (aliased object with a long key)', async () => {
+    const longKey = 'k'.repeat(2000)
+    const lines: string[] = [`l0: &l0 {${longKey}: 1}`]
+    for (let i = 1; i <= 8; i++) {
+      lines.push(
+        `l${i}: &l${i} [${Array(10)
+          .fill(`*l${i - 1}`)
+          .join(',')}]`
+      )
+    }
+    lines.push(`root: [${Array(10).fill('*l8').join(',')}]`)
+    const bomb = lines.join('\n')
+    expect(Buffer.byteLength(bomb)).toBeLessThan(4096)
+    await expect(parseYAMLBuffer(Buffer.from(bomb))).rejects.toBeInstanceOf(YamlComplexityError)
+  })
+
   it('surfaces malformed YAML as an Invalid YAML error', async () => {
     await expect(parseYAMLBuffer(Buffer.from('key: "unterminated\n'))).rejects.toThrow(
       /Invalid YAML/
@@ -75,4 +91,25 @@ describe('assertYamlWithinLimits', () => {
     node.self = node
     expect(() => assertYamlWithinLimits(node)).toThrow(YamlComplexityError)
   })
+
+  it('charges object keys, not just values', () => {
+    const hugeKey = 'k'.repeat(70 * 1024 * 1024)
+    expect(() => assertYamlWithinLimits({ [hugeKey]: 1 })).toThrow(YamlComplexityError)
+  })
+
+  it('rejects a large plain-text value only when it truly exceeds the size cap', () => {
+    // ~10 MB of plain ASCII serializes ~1:1 and must be accepted (no false positive).
+    expect(() => assertYamlWithinLimits({ text: 'a'.repeat(10 * 1024 * 1024) })).not.toThrow()
+    // ~70 MB exceeds the 64 MB cap and must be rejected.
+    expect(() => assertYamlWithinLimits({ text: 'a'.repeat(70 * 1024 * 1024) })).toThrow(
+      YamlComplexityError
+    )
+  })
+
+  it('charges the true escaped length of escape-heavy strings', () => {
+    // ~11M control chars each serialize to a six-char \uXXXX escape (~66 MB > 64 MB).
+    const escapeHeavy = '
'.repeat(11 * 1024 * 1024)
+    expect(() => assertYamlWithinLimits({ text: escapeHeavy })).toThrow(YamlComplexityError)
+    expect(escapeHeavy.length).toBeLessThan(64 * 1024 * 1024)
+  })
 })

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

@@ -42,60 +42,121 @@ export class YamlComplexityError extends Error {
 }
 
 /**
- * Estimate the pretty-printed (`JSON.stringify(value, null, 2)`) byte cost a
- * single node contributes, including the indentation/newline overhead that
- * dominates deeply nested alias bombs.
+ * Type guard for {@link YamlComplexityError}. Callers use this to fail closed on
+ * a complexity-limit rejection instead of falling back to a generic parse.
+ */
+export function isYamlComplexityError(error: unknown): error is YamlComplexityError {
+  return error instanceof YamlComplexityError
+}
+
+/**
+ * Exact serialized length (in UTF-16 code units — the unit V8 allocates for the
+ * resulting string) that `JSON.stringify` produces for a string, accounting for
+ * the escape expansion of quotes, backslashes, and control characters. Computed
+ * precisely rather than with a flat multiplier so plain text is charged its
+ * true size (no false rejection of large legitimate documents) while
+ * escape-heavy strings are charged their real, larger cost (no cap bypass).
+ */
+function serializedStringLength(value: string): number {
+  let length = 2 // surrounding quotes
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if (code === 0x22 /* " */ || code === 0x5c /* \ */) {
+      length += 2
+    } else if (code < 0x20) {
+      // \b \t \n \f \r use two-char escapes; other control chars use \uXXXX (six)
+      length +=
+        code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d ? 2 : 6
+    } else {
+      length += 1
+    }
+  }
+  return length
+}
+
+/**
+ * Estimate the pretty-printed (`JSON.stringify(value, null, 2)`) size a single
+ * value node contributes, including the indentation/newline overhead that
+ * dominates deeply nested alias bombs and the exact escape expansion of strings.
  */
 function estimateNodeBytes(value: unknown, depth: number): number {
   const indentOverhead = depth * 2 + 4
-  if (typeof value === 'string') return indentOverhead + value.length + 2
+  if (typeof value === 'string') return indentOverhead + serializedStringLength(value)
   return indentOverhead + 16
 }
 
+/**
+ * Estimate the serialized size of an object key (`"key": `). Keys are re-emitted
+ * on every alias expansion of their parent object, so an aliased object with a
+ * long key amplifies just like an aliased value — this must be charged or the
+ * size cap is trivially bypassed.
+ */
+function estimateKeyBytes(key: string): number {
+  return serializedStringLength(key) + 2 // ": "
+}
+
 /**
  * Iteratively walk the parsed YAML value with strict node-count, output-size,
  * and depth limits, returning the document depth. Repeated (aliased) references
  * are intentionally counted each time they are reached, mirroring the way
  * `JSON.stringify` expands them — this is what makes the alias-expansion bomb
  * detectable before serialization.
  *
+ * Each node is charged against the caps as it is *enqueued*, before its own
+ * children are pushed, and only container nodes are pushed onto the traversal
+ * stack. A pathologically wide fan-out (e.g. an array of millions of aliases)
+ * therefore trips a cap during the enqueue loop instead of first materializing
+ * millions of stack entries and exhausting memory inside the guard itself.
+ *
  * @throws {YamlComplexityError} when any limit is exceeded
  */
 export function assertYamlWithinLimits(root: unknown): number {
   let visited = 0
   let estimatedBytes = 0
   let maxDepth = 0
 
-  const stack: Array<{ value: unknown; depth: number }> = [{ value: root, depth: 0 }]
-
-  while (stack.length > 0) {
-    const { value, depth } = stack.pop()!
-
+  const charge = (bytes: number): void => {
     if (++visited > MAX_YAML_EXPANDED_NODES) {
       throw new YamlComplexityError(
         `YAML document exceeds the maximum of ${MAX_YAML_EXPANDED_NODES} expanded nodes (possible alias-expansion bomb)`
       )
     }
-
-    estimatedBytes += estimateNodeBytes(value, depth)
+    estimatedBytes += bytes
     if (estimatedBytes > MAX_YAML_SERIALIZED_BYTES) {
       throw new YamlComplexityError(
         `YAML document expands beyond the maximum serialized size of ${MAX_YAML_SERIALIZED_BYTES} bytes (possible alias-expansion bomb)`
       )
     }
+  }
+
+  const isContainer = (value: unknown): value is object =>
+    value !== null && typeof value === 'object'
 
-    if (value === null || typeof value !== 'object') continue
+  charge(estimateNodeBytes(root, 0))
+  const stack: Array<{ value: object; depth: number }> = []
+  if (isContainer(root)) stack.push({ value: root, depth: 0 })
+
+  while (stack.length > 0) {
+    const { value, depth } = stack.pop()!
+    const childDepth = depth + 1
 
-    if (depth + 1 > maxDepth) maxDepth = depth + 1
-    if (depth + 1 > MAX_YAML_DEPTH) {
+    if (childDepth > maxDepth) maxDepth = childDepth
+    if (childDepth > MAX_YAML_DEPTH) {
       throw new YamlComplexityError(
         `YAML document exceeds the maximum nesting depth of ${MAX_YAML_DEPTH}`
       )
     }
 
-    const children = Array.isArray(value) ? value : Object.values(value as Record<string, unknown>)
-    for (const child of children) {
-      stack.push({ value: child, depth: depth + 1 })
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        charge(estimateNodeBytes(child, childDepth))
+        if (isContainer(child)) stack.push({ value: child, depth: childDepth })
+      }
+    } else {
+      for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+        charge(estimateKeyBytes(key) + estimateNodeBytes(child, childDepth))
+        if (isContainer(child)) stack.push({ value: child, depth: childDepth })
+      }
     }
   }