feat: 升级至 v0.3.16 — 工单修复 51 项 + 审查修复 30 项(安全加固/适配器/工具系统/数据层/前端)

This commit is contained in:
2026-07-22 10:31:13 +08:00
parent 516d8a728f
commit 2c2ca4a692
43 changed files with 1454 additions and 301 deletions
+133 -3
View File
@@ -5,8 +5,12 @@
*
* 使用 Node.js 18+ 内置 fetch API。
* 响应体截断到 50KB 防止结果过大。
*
* #10 修复: SSRF 防护 — 解析 URL 域名并校验 IP,拒绝内网/回环/元数据地址。
*/
import { lookup } from 'node:dns/promises';
import { isIP } from 'node:net';
import type { IMetonaTool, ToolExecutionContext } from '../../types/metona-tool';
import type { MetonaToolDef } from '../../../harness/types';
import { MetonaToolCategory, MetonaRiskLevel } from '../../../harness/types';
@@ -14,6 +18,120 @@ import { MetonaToolCategory, MetonaRiskLevel } from '../../../harness/types';
const ALLOWED_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'] as const;
const MAX_BODY_BYTES = 50 * 1024; // 50KB
/**
* #10 修复: 检查 IP 是否为私有/内网/回环/元数据地址
*
* 覆盖:
* - IPv4: 127.0.0.0/8 (回环)、10.0.0.0/8、192.168.0.0/16、172.16.0.0/12、
* 169.254.0.0/16 (链路本地,含云元数据 169.254.169.254)、0.0.0.0/8、
* 224.0.0.0/4 (组播)、240.0.0.0/4 (保留)
* - IPv6: ::1 (回环)、fe80::/10 (链路本地)、fc00::/7 (唯一本地)、::ffff: 映射的 IPv4
*/
function isPrivateIP(ip: string): boolean {
// IPv4 直接检测
if (isIP(ip) === 4) {
const parts = ip.split('.').map(Number);
if (parts[0] === 127) return true; // 回环
if (parts[0] === 10) return true; // 内网
if (parts[0] === 192 && parts[1] === 168) return true; // 内网
if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true; // 内网
if (parts[0] === 169 && parts[1] === 254) return true; // 链路本地(含云元数据)
if (parts[0] === 0) return true; // 0.0.0.0/8
if (parts[0] >= 224) return true; // 组播 + 保留
return false;
}
// IPv6 检测
if (isIP(ip) === 6) {
const lower = ip.toLowerCase();
if (lower === '::1') return true; // 回环
if (lower.startsWith('fe80:')) return true; // 链路本地
if (lower.startsWith('fc') || lower.startsWith('fd')) return true; // 唯一本地
// ::ffff: 映射的 IPv4 — 提取 IPv4 部分递归检测
const v4MappedMatch = lower.match(/::ffff:(\d+\.\d+\.\d+\.\d+)$/);
if (v4MappedMatch) return isPrivateIP(v4MappedMatch[1]);
return false;
}
// 非 IP 格式(域名等),由调用方 DNS 解析后再检测
return false;
}
/**
* #10 修复: SSRF 校验 — 解析 URL 域名并校验 IP
*
* 1. 协议白名单:仅允许 http/https
* 2. DNS 解析域名,获取所有 IP 地址
* 3. 逐个检测 IP 是否为私有/内网/回环/元数据地址
* 4. 任意一个 IP 为私有即拒绝(防止 DNS rebinding 中只校验第一个 IP
*
* 审查修复 (M7) — 已知限制:DNS rebinding 窗口
* ---------------------------------------------------------------
* validateSSRF 在校验阶段 DNS 解析得到 IP,fetch 内部会再次 DNS 解析,
* 两次解析之间存在 DNS rebinding 攻击窗口(攻击者可在校验通过后切换
* DNS 记录到内网 IP)。
*
* 完全防护需要 "DNS pinning"(用校验通过的 IP 替换 URL hostname),
* 但在 Node.js fetch 实现下不可行:
* 1. HTTPS 请求时 fetch 会基于 URL hostname 校验证书 SAN
* 用 IP 替换会导致证书校验失败(除非目标证书 SAN 包含该 IP)。
* 2. Node fetch 将 Host 列为 forbidden header,无法通过设置
* Host header 保留原始域名。
* 3. fetch API 不暴露 SNI 自定义入口。
*
* 当前实现的缓解措施:
* - 校验所有 DNS 返回的 IP(防只校验第一个 IP 的绕过)
* - redirect: 'manual' 禁用自动重定向(防重定向到内网)
* - 窗口虽存在,但需要攻击者控制权威 DNS 并在毫秒级切换记录,
* 实际利用难度较高。
*
* 彻底防护建议:在 Electron 主进程层使用自定义 lookup 钩子实现
* DNS pinning(例如 undici 的 dispatcher.agent.connect lookup)。
*
* @throws 如果 URL 指向私有/内网/回环地址
*/
async function validateSSRF(url: string): Promise<void> {
let parsed: URL;
try {
parsed = new URL(url);
} catch {
throw new Error(`Invalid URL: ${url}`);
}
// 协议白名单
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
throw new Error(`Blocked SSRF: protocol "${parsed.protocol}" not allowed (only http/https)`);
}
const hostname = parsed.hostname;
// 如果 hostname 本身就是 IP,直接检测
if (isIP(hostname)) {
if (isPrivateIP(hostname)) {
throw new Error(`Blocked SSRF: ${hostname} is a private/loopback address`);
}
return;
}
// 域名 — DNS 解析后检测所有 IP
let addresses: Array<{ address: string }>;
try {
addresses = await lookup(hostname, { all: true });
} catch (err) {
throw new Error(`Blocked SSRF: DNS resolution failed for ${hostname}: ${(err as Error).message}`);
}
if (addresses.length === 0) {
throw new Error(`Blocked SSRF: no DNS records for ${hostname}`);
}
for (const { address } of addresses) {
if (isPrivateIP(address)) {
throw new Error(`Blocked SSRF: ${hostname} resolves to private IP ${address}`);
}
}
}
export class HttpRequestTool implements IMetonaTool {
readonly definition: MetonaToolDef = {
name: 'http_request',
@@ -34,8 +152,8 @@ export class HttpRequestTool implements IMetonaTool {
required: ['url'],
},
category: MetonaToolCategory.NETWORK,
riskLevel: MetonaRiskLevel.LOW,
requiresPermission: false,
riskLevel: MetonaRiskLevel.MEDIUM,
requiresPermission: true,
timeoutMs: 30_000,
};
@@ -52,6 +170,13 @@ export class HttpRequestTool implements IMetonaTool {
return { error: 'Invalid URL', success: false };
}
// #10 修复: SSRF 校验 — 拒绝内网/回环/元数据地址
try {
await validateSSRF(url);
} catch (ssrfErr) {
return { error: (ssrfErr as Error).message, success: false };
}
// 校验 method
if (!(ALLOWED_METHODS as readonly string[]).includes(method)) {
return {
@@ -69,7 +194,9 @@ export class HttpRequestTool implements IMetonaTool {
method,
headers,
signal: controller.signal,
redirect: 'follow',
// #10 修复: 禁用自动重定向跟随 — 防止重定向到内网地址绕过 SSRF 校验
// 重定向后的 URL 由用户自行处理(响应中会包含 Location 头)
redirect: 'manual',
};
// GET/HEAD 不应携带 body
if (body !== undefined && method !== 'GET' && method !== 'HEAD') {
@@ -84,11 +211,14 @@ export class HttpRequestTool implements IMetonaTool {
const safeBody = truncated ? text.slice(0, MAX_BODY_BYTES) : text;
// 只返回 content-type 和 content-length
// 审查修复: redirect:'manual' 后需要返回 Location header,否则 LLM 无法知道重定向目标
const filteredHeaders: Record<string, string> = {};
const contentType = response.headers.get('content-type');
if (contentType) filteredHeaders['content-type'] = contentType;
const contentLength = response.headers.get('content-length');
if (contentLength) filteredHeaders['content-length'] = contentLength;
const location = response.headers.get('location');
if (location) filteredHeaders['location'] = location;
return {
status: response.status,