SSRF 校验补 DNS 解析与每一跳重校验,重定向手动跟随,超时夹紧、响应体截断 2MB;订单工具改用 userId 隔离并转义正则;沙箱固定拦截 .git/.env/密钥文件;环境变量脱敏改为命名模式兜底并删除 env_set。
125 lines
4.1 KiB
JavaScript
125 lines
4.1 KiB
JavaScript
/**
|
|
* 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 };
|