/** * Agent 出网 HTTP 客户端:统一承载 SSRF 校验、重定向控制、超时上限与响应体截断。 * * http_get / http_post 只负责参数整理,真正的安全约束集中在这里, * 避免两个工具各写一套、修了一个漏掉另一个。 * * 约束: * - 每一跳都重新做同步 + DNS 校验,最多 3 跳(重定向可被用来绕过首次校验); * - POST 不跟随重定向(303/302 会改写成 GET,语义与安全性都不可控); * - 超时由服务端夹紧到 1s~15s,不接受模型传入的任意大值; * - 响应体最多读取 2MB,超出即截断并标记 truncated。 */ import { checkUrlAllowedAsync } from "./url_guard.js"; const DEFAULT_TIMEOUT = 15000; const MAX_TIMEOUT = 15000; const MAX_REDIRECTS = 3; const MAX_BODY_BYTES = 2 * 1024 * 1024; const REDIRECT_STATUS = new Set([301, 302, 303, 307, 308]); /** * 夹紧超时:非法值用默认值,过大值截到上限 * @param {number} timeout 调用方传入的毫秒数 * @returns {number} */ function clampTimeout(timeout) { const value = Number(timeout); if (!Number.isFinite(value) || value <= 0) return DEFAULT_TIMEOUT; return Math.min(Math.max(value, 1000), MAX_TIMEOUT); } /** * 读取响应体,超过上限时截断 * @param {Response} response fetch 响应 * @returns {Promise<{buffer: Buffer, truncated: boolean}>} */ async function readBodyLimited(response) { if (!response.body) return { buffer: Buffer.alloc(0), truncated: false }; const reader = response.body.getReader(); const chunks = []; let size = 0; let truncated = false; while (true) { const { done, value } = await reader.read(); if (done) break; const chunk = Buffer.from(value); if (size + chunk.length > MAX_BODY_BYTES) { chunks.push(chunk.subarray(0, MAX_BODY_BYTES - size)); size = MAX_BODY_BYTES; truncated = true; await reader.cancel().catch(() => {}); break; } chunks.push(chunk); size += chunk.length; } return { buffer: Buffer.concat(chunks), truncated }; } /** * 发起受控的 HTTP 请求 * @param {string} url 目标地址 * @param {Object} options * @param {string} [options.method] 请求方法 * @param {Object} [options.headers] 请求头 * @param {string} [options.body] 请求体 * @param {number} [options.timeout] 超时毫秒数(会被夹紧) * @returns {Promise<{status:number,statusText:string,headers:Object,buffer:Buffer,text:string,truncated:boolean,url:string}>} */ async function safeFetch(url, options = {}) { const method = (options.method || "GET").toUpperCase(); const timeout = clampTimeout(options.timeout); let currentUrl = url; for (let hop = 0; hop <= MAX_REDIRECTS; hop++) { // 每一跳都重新校验,防止「公网地址 302 到内网」绕过首次检查 const blocked = await checkUrlAllowedAsync(currentUrl); if (blocked) throw new Error(blocked); const controller = new AbortController(); const timer = setTimeout(() => controller.abort(), timeout); try { const response = await fetch(currentUrl, { method, headers: options.headers, body: options.body, redirect: "manual", signal: controller.signal, }); if (REDIRECT_STATUS.has(response.status)) { const location = response.headers.get("location"); await response.body?.cancel().catch(() => {}); if (!location) throw new Error(`Redirect without location: ${response.status}`); if (method !== "GET") throw new Error("Redirects are not followed for non-GET requests"); currentUrl = new URL(location, currentUrl).toString(); continue; } const { buffer, truncated } = await readBodyLimited(response); return { status: response.status, statusText: response.statusText, headers: Object.fromEntries(response.headers.entries()), buffer, text: buffer.toString("utf8"), truncated, url: currentUrl, }; } finally { clearTimeout(timer); } } throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`); } export { safeFetch, clampTimeout };