Files
2026-10-28 11:15:29 +08:00

118 lines
3.7 KiB
JavaScript

/**
* Agent 出网 HTTP 客户端:统一承载 SSRF 校验、重定向控制、超时上限与响应体截断。
*
* 目前只有 http_get 使用,安全约束集中在这里,避免工具各自实现一套。
*
* 约束:
* - 每一跳都重新做同步 + DNS 校验,最多 3 跳(重定向可被用来绕过首次校验);
* - 超时由服务端夹紧到 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 };
}
/**
* 发起受控的 GET 请求
* @param {string} url 目标地址
* @param {Object} [options]
* @param {Object} [options.headers] 请求头
* @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 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: "GET",
headers: options.headers,
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}`);
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 };