19.06-请求体大小限制

import { Hono } from 'hono'
import { bodyLimit } from 'hono/body-limit'
 
const app = new Hono()
 
// 全局限制：1MB
app.use('/api/*', bodyLimit({
  maxSize: 1024 * 1024,  // 1MB
  onError: (c) => {
    return c.json({ error: 'Request body too large' }, 413)
  },
}))

// JSON API：最大 100KB
app.use('/api/*', bodyLimit({
  maxSize: 100 * 1024,  // 100KB
}))
 
// AI 对话接口：最大 500KB（prompt 可能很长）
app.use('/api/ai/*', bodyLimit({
  maxSize: 500 * 1024,  // 500KB
}))
 
// 文件上传接口：最大 10MB
app.use('/api/upload/*', bodyLimit({
  maxSize: 10 * 1024 * 1024,  // 10MB
}))

请求 → Content-Length: 5000000
     → bodyLimit 检查：5MB > 1MB → 返回 413，不调 handler
     → 请求体没有被读进内存

// AI 接口的请求体限制
app.use('/api/ai/*', bodyLimit({
  maxSize: 500 * 1024,  // 500KB，足够放下 200K tokens 的 prompt
}))
 
// 在业务层再限制 prompt 长度
app.post('/api/ai/chat', async (c) => {
  const body = await c.req.json()
  const messages = body.messages
 
  // 计算 prompt 总长度（简单估算：1 token ≈ 4 字符）
  const totalChars = messages.reduce((sum, msg) => sum + msg.content.length, 0)
  const estimatedTokens = Math.ceil(totalChars / 4)
 
  if (estimatedTokens > 100000) {  // 限制 100K tokens
    return c.json({ error: 'Prompt too long' }, 400)
  }
 
  // ...
})

// 用 Zod 验证请求体结构
import { z } from 'zod'
 
const chatSchema = z.object({
  messages: z.array(z.object({
    role: z.enum(['user', 'assistant', 'system']),
    content: z.string().max(50000),  // 单条消息最多 50K 字符
  })).max(100),  // 最多 100 条消息
  model: z.string().max(100),
  temperature: z.number().min(0).max(2),
})
 
app.post('/api/ai/chat', async (c) => {
  const body = await c.req.json()
  const parsed = chatSchema.safeParse(body)
 
  if (!parsed.success) {
    return c.json({ error: parsed.error.message }, 400)
  }
 
  // 验证通过，安全使用 parsed.data
})

// 危险：不限制数组长度
const items = await c.req.json()  // { "items": [1, 2, 3, ...1000000个] }
for (const item of items) {
  await c.env.DB.prepare('INSERT INTO items (value) VALUES (?)').bind(item).run()
}
// 100 万次数据库写入——Worker CPU 时间直接爆掉

// 正确：限制数组长度
const MAX_ITEMS = 1000
if (items.length > MAX_ITEMS) {
  return c.json({ error: `Too many items (max ${MAX_ITEMS})` }, 400)
}

{"a": {"a": {"a": {"a": ...}}}}

// 防御：限制 JSON 嵌套深度
function parseJsonWithDepthLimit(str: string, maxDepth = 10): any {
  let depth = 0
  let inString = false
  let escape = false
 
  for (const char of str) {
    if (escape) { escape = false; continue }
    if (char === '\\') { escape = true; continue }
    if (char === '"') { inString = !inString; continue }
    if (inString) continue
 
    if (char === '{' || char === '[') {
      depth++
      if (depth > maxDepth) throw new Error('JSON too deeply nested')
    }
    if (char === '}' || char === ']') {
      depth--
    }
  }
 
  return JSON.parse(str)
}

app.post('/api/upload', async (c) => {
  // 设置读取请求体的超时
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), 30000)
  )
 
  try {
    const body = await Promise.race([
      c.req.parseBody(),
      timeout,
    ])
    // ...
  } catch (e) {
    if (e.message === 'Timeout') {
      return c.json({ error: 'Request timeout' }, 408)
    }
    throw e
  }
})

第 1 层：Cloudflare 边缘（100MB / 500MB）
  ↓
第 2 层：Hono bodyLimit 中间件（按路由设置）
  ↓
第 3 层：Zod 验证（字段级限制）
  ↓
第 4 层：业务逻辑（数组长度、prompt token 数）

import { Hono } from 'hono'
import { bodyLimit } from 'hono/body-limit'
import { z } from 'zod'
 
const app = new Hono()
 
// 第 2 层：bodyLimit
app.use('/api/*', bodyLimit({ maxSize: 1024 * 1024 }))  // 1MB
app.use('/api/ai/*', bodyLimit({ maxSize: 500 * 1024 }))  // 500KB
app.use('/api/upload/*', bodyLimit({ maxSize: 10 * 1024 * 1024 }))  // 10MB
 
// 第 3 层 + 第 4 层：Zod 验证 + 业务限制
const chatSchema = z.object({
  messages: z.array(z.object({
    role: z.enum(['user', 'assistant', 'system']),
    content: z.string().max(50000),
  })).max(100),
  model: z.string().max(100),
})
 
app.post('/api/ai/chat', async (c) => {
  const body = await c.req.json()
  const parsed = chatSchema.safeParse(body)
 
  if (!parsed.success) {
    return c.json({ error: 'Invalid request' }, 400)
  }
 
  // 第 4 层：token 数估算
  const totalChars = parsed.data.messages.reduce(
    (sum, msg) => sum + msg.content.length, 0
  )
  if (totalChars > 400000) {  // ~100K tokens
    return c.json({ error: 'Prompt too long' }, 400)
  }
 
  // 业务逻辑...
  return c.json({ ok: true })
})