fix(ssh/sftp): cap remote file reads on received bytes, not stat() size

The SFTP/SSH download routes buffered a remote file into memory with the
only size guard being sftp.stat().size — a value the caller-supplied SSH
server controls. A server that reports a tiny size and then streams
endlessly drove unbounded heap growth until OOM.

Add readSftpFileCapped(), which counts received bytes and destroys the
stream as soon as the cap is exceeded, and route all four SFTP-reading
tool routes through it (download, download-file, read-file-content, and
the append path of write-file-content, which had no cap at all). Cap
breaches now return 400 instead of 500, and responses report the actual
byte count rather than the server-reported stat size.

Author: waleedlatif1

apps/sim/app/api/tools/sftp/download/route.ts

@@ -8,7 +8,15 @@ import { checkInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { getFileExtension, getMimeTypeFromExtension } from '@/lib/uploads/utils/file-utils'
-import { createSftpConnection, getSftp, isPathSafe, sanitizePath } from '@/app/api/tools/sftp/utils'
+import {
+  createSftpConnection,
+  getSftp,
+  isPathSafe,
+  MAX_SFTP_READ_BYTES,
+  readSftpFileCapped,
+  SftpFileTooLargeError,
+  sanitizePath,
+} from '@/app/api/tools/sftp/utils'
 
 export const dynamic = 'force-dynamic'
 
@@ -73,8 +81,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         })
       })
 
-      const maxSize = 50 * 1024 * 1024
-      if (stats.size > maxSize) {
+      if (stats.size > MAX_SFTP_READ_BYTES) {
         const sizeMB = (stats.size / (1024 * 1024)).toFixed(2)
         return NextResponse.json(
           { success: false, error: `File size (${sizeMB}MB) exceeds download limit of 50MB` },
@@ -84,19 +91,12 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
       logger.info(`[${requestId}] Downloading file ${remotePath} (${stats.size} bytes)`)
 
-      const chunks: Buffer[] = []
-      await new Promise<void>((resolve, reject) => {
-        const readStream = sftp.createReadStream(remotePath)
-
-        readStream.on('data', (chunk: Buffer) => {
-          chunks.push(chunk)
-        })
-
-        readStream.on('end', () => resolve())
-        readStream.on('error', reject)
-      })
-
-      const buffer = Buffer.concat(chunks)
+      const buffer = await readSftpFileCapped(
+        sftp,
+        remotePath,
+        MAX_SFTP_READ_BYTES,
+        'File exceeds download limit of 50MB'
+      )
       const fileName = path.basename(remotePath)
       const extension = getFileExtension(fileName)
       const mimeType = getMimeTypeFromExtension(extension)
@@ -129,6 +129,12 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     }
   } catch (error) {
     const errorMessage = getErrorMessage(error, 'Unknown error occurred')
+
+    if (error instanceof SftpFileTooLargeError) {
+      logger.warn(`[${requestId}] SFTP download aborted: ${errorMessage}`)
+      return NextResponse.json({ success: false, error: errorMessage }, { status: 400 })
+    }
+
     logger.error(`[${requestId}] SFTP download failed:`, error)
 
     return NextResponse.json({ error: `SFTP download failed: ${errorMessage}` }, { status: 500 })

apps/sim/app/api/tools/sftp/utils.test.ts

@@ -0,0 +1,72 @@
+/**
+ * @vitest-environment node
+ */
+import { EventEmitter } from 'events'
+import type { SFTPWrapper } from 'ssh2'
+import { describe, expect, it } from 'vitest'
+import {
+  MAX_SFTP_READ_BYTES,
+  readSftpFileCapped,
+  SftpFileTooLargeError,
+} from '@/app/api/tools/sftp/utils'
+
+class FakeReadStream extends EventEmitter {
+  destroyed = false
+
+  destroy() {
+    this.destroyed = true
+  }
+}
+
+/**
+ * Builds a fake SFTP wrapper whose read stream emits `chunkCount` chunks of
+ * `chunkSize` bytes — the shape of a malicious server that understates the
+ * file size in its stat reply and then streams unbounded data.
+ */
+function fakeSftp(chunkSize: number, chunkCount: number) {
+  const stream = new FakeReadStream()
+  const sftp = {
+    createReadStream: () => {
+      queueMicrotask(() => {
+        for (let i = 0; i < chunkCount; i++) {
+          if (stream.destroyed) return
+          stream.emit('data', Buffer.alloc(chunkSize, 0x41))
+        }
+        if (!stream.destroyed) stream.emit('end')
+      })
+      return stream
+    },
+  } as unknown as SFTPWrapper
+  return { sftp, stream }
+}
+
+describe('readSftpFileCapped', () => {
+  it('resolves with the full contents when under the cap', async () => {
+    const { sftp } = fakeSftp(4, 3)
+
+    const buffer = await readSftpFileCapped(sftp, '/file', 1024)
+
+    expect(buffer.length).toBe(12)
+    expect(buffer.toString()).toBe('A'.repeat(12))
+  })
+
+  it('rejects and destroys the stream once received bytes exceed the cap', async () => {
+    const { sftp, stream } = fakeSftp(8, 100)
+
+    await expect(readSftpFileCapped(sftp, '/bomb', 16)).rejects.toBeInstanceOf(
+      SftpFileTooLargeError
+    )
+    expect(stream.destroyed).toBe(true)
+  })
+
+  it('enforces the cap on actual bytes even when the file was reported as tiny', async () => {
+    const { sftp, stream } = fakeSftp(1024, 1024)
+
+    await expect(readSftpFileCapped(sftp, '/bomb', 4096, 'too big')).rejects.toThrow('too big')
+    expect(stream.destroyed).toBe(true)
+  })
+
+  it('caps remote reads at 50MB', () => {
+    expect(MAX_SFTP_READ_BYTES).toBe(50 * 1024 * 1024)
+  })
+})

apps/sim/app/api/tools/sftp/utils.ts

@@ -172,6 +172,53 @@ export function getSftp(client: Client): Promise<SFTPWrapper> {
   })
 }
 
+/** Maximum bytes a route will buffer from a remote SFTP file. */
+export const MAX_SFTP_READ_BYTES = 50 * 1024 * 1024
+
+/**
+ * Thrown when a remote file streams more bytes than the caller's cap allows.
+ */
+export class SftpFileTooLargeError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'SftpFileTooLargeError'
+  }
+}
+
+/**
+ * Reads a remote file into memory, enforcing the cap on the bytes actually
+ * received rather than on the `stat()` size the remote server reports.
+ * A caller-supplied SSH server can understate the size in its `SSH_FXP_STAT`
+ * reply and then stream unbounded data, so the stream is destroyed as soon as
+ * the running total exceeds `maxBytes`.
+ */
+export function readSftpFileCapped(
+  sftp: SFTPWrapper,
+  remotePath: string,
+  maxBytes: number,
+  errorMessage = `File exceeds maximum allowed size of ${maxBytes} bytes`
+): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    let totalBytes = 0
+    const readStream = sftp.createReadStream(remotePath)
+
+    readStream.on('data', (chunk: Buffer) => {
+      totalBytes += chunk.length
+      if (totalBytes > maxBytes) {
+        readStream.destroy()
+        chunks.length = 0
+        reject(new SftpFileTooLargeError(errorMessage))
+        return
+      }
+      chunks.push(chunk)
+    })
+
+    readStream.on('end', () => resolve(Buffer.concat(chunks)))
+    readStream.on('error', reject)
+  })
+}
+
 /**
  * Sanitizes a remote path to prevent path traversal attacks.
  * Removes null bytes, normalizes path separators, and collapses traversal sequences.

apps/sim/app/api/tools/ssh/download-file/route.ts

@@ -9,6 +9,11 @@ import { parseRequest } from '@/lib/api/server'
 import { checkInternalAuth } from '@/lib/auth/hybrid'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { getFileExtension, getMimeTypeFromExtension } from '@/lib/uploads/utils/file-utils'
+import {
+  MAX_SFTP_READ_BYTES,
+  readSftpFileCapped,
+  SftpFileTooLargeError,
+} from '@/app/api/tools/sftp/utils'
 import { createSSHConnection, sanitizePath } from '@/app/api/tools/ssh/utils'
 
 const logger = createLogger('SSHDownloadFileAPI')
@@ -67,31 +72,20 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         })
       })
 
-      // Check file size limit (50MB to prevent memory exhaustion)
-      const maxSize = 50 * 1024 * 1024
-      if (stats.size > maxSize) {
+      if (stats.size > MAX_SFTP_READ_BYTES) {
         const sizeMB = (stats.size / (1024 * 1024)).toFixed(2)
         return NextResponse.json(
           { error: `File size (${sizeMB}MB) exceeds download limit of 50MB` },
           { status: 400 }
         )
       }
 
-      // Read file content
-      const content = await new Promise<Buffer>((resolve, reject) => {
-        const chunks: Buffer[] = []
-        const readStream = sftp.createReadStream(remotePath)
-
-        readStream.on('data', (chunk: Buffer) => {
-          chunks.push(chunk)
-        })
-
-        readStream.on('end', () => {
-          resolve(Buffer.concat(chunks))
-        })
-
-        readStream.on('error', reject)
-      })
+      const content = await readSftpFileCapped(
+        sftp,
+        remotePath,
+        MAX_SFTP_READ_BYTES,
+        'File exceeds download limit of 50MB'
+      )
 
       const fileName = path.basename(remotePath)
       const extension = getFileExtension(fileName)
@@ -108,19 +102,25 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
           name: fileName,
           mimeType,
           data: base64Content,
-          size: stats.size,
+          size: content.length,
         },
         content: base64Content,
         fileName: fileName,
         remotePath: remotePath,
-        size: stats.size,
+        size: content.length,
         message: `File downloaded successfully from ${remotePath}`,
       })
     } finally {
       client.end()
     }
   } catch (error) {
     const errorMessage = getErrorMessage(error, 'Unknown error occurred')
+
+    if (error instanceof SftpFileTooLargeError) {
+      logger.warn(`[${requestId}] SSH file download aborted: ${errorMessage}`)
+      return NextResponse.json({ error: errorMessage }, { status: 400 })
+    }
+
     logger.error(`[${requestId}] SSH file download failed:`, error)
 
     return NextResponse.json(

apps/sim/app/api/tools/ssh/read-file-content/route.ts

@@ -7,6 +7,7 @@ import { sshReadFileContentContract } from '@/lib/api/contracts/storage-transfer
 import { parseRequest } from '@/lib/api/server'
 import { checkInternalAuth } from '@/lib/auth/hybrid'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { readSftpFileCapped, SftpFileTooLargeError } from '@/app/api/tools/sftp/utils'
 import { createSSHConnection, sanitizePath } from '@/app/api/tools/ssh/utils'
 
 const logger = createLogger('SSHReadFileContentAPI')
@@ -72,47 +73,38 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         )
       }
 
-      const content = await new Promise<string>((resolve, reject) => {
-        const chunks: Buffer[] = []
-        let totalBytes = 0
-        const readStream = sftp.createReadStream(filePath)
-
-        readStream.on('data', (chunk: Buffer) => {
-          totalBytes += chunk.length
-          if (totalBytes > maxBytes) {
-            readStream.destroy()
-            reject(new Error(`File exceeds maximum allowed size of ${params.maxSize}MB`))
-            return
-          }
-          chunks.push(chunk)
-        })
-
-        readStream.on('end', () => {
-          const buffer = Buffer.concat(chunks)
-          resolve(buffer.toString(params.encoding as BufferEncoding))
-        })
-
-        readStream.on('error', reject)
-      })
+      const buffer = await readSftpFileCapped(
+        sftp,
+        filePath,
+        maxBytes,
+        `File exceeds maximum allowed size of ${params.maxSize}MB`
+      )
+      const content = buffer.toString(params.encoding as BufferEncoding)
 
       const lines = content.split('\n').length
 
       logger.info(
-        `[${requestId}] File content read successfully: ${stats.size} bytes, ${lines} lines`
+        `[${requestId}] File content read successfully: ${buffer.length} bytes, ${lines} lines`
       )
 
       return NextResponse.json({
         content,
-        size: stats.size,
+        size: buffer.length,
         lines,
         path: filePath,
-        message: `File read successfully: ${stats.size} bytes, ${lines} lines`,
+        message: `File read successfully: ${buffer.length} bytes, ${lines} lines`,
       })
     } finally {
       client.end()
     }
   } catch (error) {
     const errorMessage = getErrorMessage(error, 'Unknown error occurred')
+
+    if (error instanceof SftpFileTooLargeError) {
+      logger.warn(`[${requestId}] SSH read file content aborted: ${errorMessage}`)
+      return NextResponse.json({ error: errorMessage }, { status: 400 })
+    }
+
     logger.error(`[${requestId}] SSH read file content failed:`, error)
 
     return NextResponse.json(