pure-js-db 2.53.0 → 2.53.2

package/README.md

@@ -3,11 +3,11 @@
 > **零依赖嵌入式数据库引擎 —— 单文件部署，同时支持向量搜索、MVCC 并发写入、CDC 变更捕获。**
 > 如果你的 Node.js 应用需要 PostgreSQL + Milvus + Debezium 的能力但不想要三个独立服务，这里一个文件就够。
 
-> 📌 **当前状态**：v2.53.0，成熟度 **Beta+（工程验证成熟）**。历史版本公告（E26 查询缓存/时间旅行、F1-F10 接线、安全审计加固等）详见 [CHANGELOG.md](CHANGELOG.md) 与 [docs/internal/audit/](docs/internal/audit/) 审计档案。安全模块默认 fail-closed，生产部署必须显式配置认证/RBAC/加密（见 [SECURITY.md](SECURITY.md) §2.2）。
+> 📌 **当前状态**：v2.53.2，成熟度 **Beta+（工程验证成熟）**。历史版本公告（E26 查询缓存/时间旅行、F1-F10 接线、安全审计加固等）详见 [CHANGELOG.md](CHANGELOG.md) 与 [docs/internal/audit/](docs/internal/audit/) 审计档案。安全模块默认 fail-closed，生产部署必须显式配置认证/RBAC/加密（见 [SECURITY.md](SECURITY.md) §2.2）。
 
 ![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)
 ![License](https://img.shields.io/badge/license-MIT-blue)
-![Version](https://img.shields.io/badge/version-2.53.0-blue)
+![Version](https://img.shields.io/badge/version-2.53.2-blue)
 ![Tests](https://img.shields.io/badge/tests-826%20files-brightgreen)
 ![LOC](https://img.shields.io/badge/loc-~225k-blue)
 ![Maturity](https://img.shields.io/badge/maturity-Beta%2B%20engineering%20validated-orange)
@@ -121,6 +121,8 @@ SELECT * FROM cdc_events WHERE table_name = 'orders' AND op = 'C';
 
 内置 MCP Server，AI 工具（Cursor / Claude Code / Claude Desktop）一键直连。
 
+> 💡 **新手教程**：📘《用 Pure-JS-DB 给 Claude 一个本地记忆库》— [docs/tutorials/ai-agent-local-memory.md](docs/tutorials/ai-agent-local-memory.md)（MCP 安装 / Claude Desktop 配置 / 可复现示例，全程 3 步跑通建表+写入+查询）。
+
 **方式 A：CLI 一键启动（推荐）**
 
 ```bash
@@ -385,6 +387,7 @@ npm install pure-js-db
 | `src/serializer/serializer.js` | 列式序列化/反序列化，自动分页 |
 | `src/storage/kv-adapter.js` | Memory / LocalStorage / WeChat(miniprogram) 三种 KV 适配器 |
 | `src/storage/persisted-db.js` | 继承 Database，脏表标记增量保存，索引持久化 |
+| `src/fdw/fdw-manager.js` | ⚠️ **实验性功能，当前未接线**：`CREATE FOREIGN TABLE ... USING csv/json/mysql/postgres` 仅注册包装器，`SELECT` **不会**路由到外部数据源（查询会报"表不存在"）。**不要依赖该语法读取文件或连接外部数据库**（2026-10-31 渗透测试确认，避免误用导致安全假象） |
 
 ### 向量搜索（~2,500+ 行）
 
@@ -476,6 +479,7 @@ npm install pure-js-db
 | 🏗️ 架构师 / 决策者 | [COMPARISON 目录](docs/comparison/) — 项目成熟度深度评估 + 主流数据库对比 |
 | 📖 查 API 细节 | [API-REFERENCE.md](docs/API-REFERENCE.md) — 66 章节 API 参考手册 |
 | 🤖 AI 集成 | [AI-FEATURES-GUIDE.md](docs/AI-FEATURES-GUIDE.md) — MCP Server / AI_FUNCTION / Text-to-SQL |
+| 🧪 AI Agent 实战教程 | [本地记忆库（MCP）](docs/tutorials/ai-agent-local-memory.md) · [本地语义搜索（向量 RAG）](docs/tutorials/ai-agent-vector-rag.md) · [知识图谱（SQL:2023 PGQ）](docs/tutorials/ai-agent-graph-pgq.md) — 三步让 AI 拥有本地持久记忆/检索/图谱；示例可直接运行 `examples/ai-agent-*.mjs` |
 | 🔧 架构理解 | [ARCHITECTURE.md](ARCHITECTURE.md) |
 | 🔒 安全 / 合规 | [SECURITY.md](SECURITY.md) — SOC2/ISO27001 合规路线图 + 17 项安全控制 + VDP 漏洞披露 + [USER-GUIDE §14 安全](docs/USER-GUIDE.md#14-安全rbac--加密--sql-防火墙) + [CVE-RESPONSE-PROCESS.md](docs/CVE-RESPONSE-PROCESS.md) |
 | 🤝 社区贡献 | [CONTRIBUTING.md](CONTRIBUTING.md) — 12 章节贡献指南 + [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) — Contributor Covenant 2.1 |
@@ -601,6 +605,14 @@ Pure-JS-DB 架构：
 - NAPI 调用开销 (~300ns) 在频繁调用中抵消 SIMD 收益
 - 核心引擎的解析/执行/存储/事务仍是 JS 瓶颈
 
+### native/index.node 的来源与可复现构建（供应链透明度）
+
+> 2026-10-31 渗透测试 L-04 补充：npm 发布包内的 `native/index.node` 是**预编译 napi 二进制**，无法从包内直接审计源码。供应链审计建议如下：
+>
+> - **来源**：由仓库 `native/` 下的 Rust 源码构建（`npm run prebuild-native` → `scripts/prebuild-native.cjs`），源码随仓库发布，可审计。
+> - **可复现构建**：在安装 Rust 工具链（`cargo`）与 Node 的干净环境执行 `npm run prebuild-native`，应产出相同功能的 `native/index.node`；建议在 CI 中记录产物 **SHA-256** 并与发布物比对。
+> - **安全回退**：未配置/缺失 `native/index.node` 时 `isNativeAvailable()` 返回 `false`，数据库功能完整可用（纯 JS 回退），不影响正确性——若无法审计预编译产物，可直接删除该文件以强制纯 JS 模式。
+
 ### Pure-JS-DB 的核心价值
 
 **不是性能，而是部署灵活性和零依赖**：
@@ -687,7 +699,7 @@ const backend = getAccelerationBackend();
 
 ### Rust NAPI 加速引擎性能 (SIMD)
 
-> ⚠️ **2026-10-27 独立评测修正（2026-10-28 部分已修复）**：下表数据来自 v1.32 时代的旧基准。独立评测实测发现：Rust 加速层多数路径未在生产代码接线（4/5 性能声称失效）；评测同时暴露三处 AVX2 正确性 bug（utf8 批量编码、Float64 min/max 全 NaN、null bitmap ≥0x80），该三处已在 2026-10-28 修复并重建 `native/index.node`、相关 Native 路径已恢复。下表加速比仅供参考，不构成当前版本（v2.53.0）的性能承诺。
+> ⚠️ **2026-10-27 独立评测修正（2026-10-28 部分已修复）**：下表数据来自 v1.32 时代的旧基准。独立评测实测发现：Rust 加速层多数路径未在生产代码接线（4/5 性能声称失效）；评测同时暴露三处 AVX2 正确性 bug（utf8 批量编码、Float64 min/max 全 NaN、null bitmap ≥0x80），该三处已在 2026-10-28 修复并重建 `native/index.node`、相关 Native 路径已恢复。下表加速比仅供参考，不构成当前版本（v2.53.2）的性能承诺。
 >
 > 详见 [SIMD 优化报告](docs/simd/simd-final-optimization-report.md)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pure-js-db",
-  "version": "2.53.0",
+  "version": "2.53.2",
   "description": "Pure JavaScript 关系型数据库引擎 - 面向小程序/受限运行时环境。零 C/C++/WASM 依赖，支持 SQL 解析、B+树索引、查询优化、物化视图、数据分片、分布式事务、Worker Pool 并行、SharedArrayBuffer 共享内存、HTAP 混合存储、多语言客户端 SDK。可选 Rust NAPI 原生加速层（编译后性能提升 2-5x）。",
   "type": "module",
   "main": "src/index.js",
@@ -70,6 +70,15 @@
     "test:bundle": "node test/bundle/bundle-verify.test.js",
     "prepublishOnly": "npm run prepublish-check && node scripts/prebuild-native.cjs && npm test && npm run bundle",
     "prepublish-check": "node scripts/pre-publish-check.cjs",
+    "release:patch": "node scripts/release-version.cjs patch",
+    "release:minor": "node scripts/release-version.cjs minor",
+    "release:major": "node scripts/release-version.cjs major",
+    "health:check": "node scripts/prod-health-check.cjs --skip-perf",
+    "ci:container": "bash scripts/ci-container.sh all",
+    "ci:container:quick": "bash scripts/ci-container.sh quick 20",
+    "dist:stress": "bash scripts/docker-distributed/run-distributed.sh 30",
+    "dist:partition": "bash scripts/docker-distributed/run-partition.sh 8",
+    "npm:downloads": "node scripts/record-npm-downloads.mjs",
     "prebuild-native": "node scripts/prebuild-native.cjs",
     "typecheck": "tsc --noEmit --project tsconfig.json",
     "test:ts": "tsc --noEmit --project tsconfig.json",

package/src/ai/ai-service.js

@@ -10,6 +10,8 @@
  *   - 模拟模式 (用于测试)
  */
 
+import { SSRFGuard } from '../security/ssrf-guard.js';
+
 export class AIService {
   constructor(options = {}) {
     this.provider = options.provider || 'mock';
@@ -183,55 +185,33 @@ class BaseClient {
 
 /**
  * 轻量级 SSRF URL 校验（用于 AI Service 内部）
- * 完整防护见 src/security/ssrf-guard.js
- * @param {string} urlStr
- * @param {boolean} allowLoopback
+ *
+ * 2026-10-31 渗透测试 M-05 修复：改用完整 SSRFGuard（IPv4 编码/私有网段/IPv6/协议/端口），
+ * 原实现只匹配点分 IPv4，`http://[::1]:8080/`、`::ffff:127.0.0.1`、十六进制/八进制 IP 变体均可绕过。
+ * 为兼容本地 LLM（Ollama 等自定义端口），将目标 URL 自身端口并入 allowedPorts。
+ * 注意：重定向跟随仍由 fetch 默认行为决定，如需逐跳复验应改用 SSRFGuard.safeFetch。
  */
 function _validateSSRFUrl(urlStr, allowLoopback) {
-  if (typeof urlStr !== 'string' || urlStr.length === 0) {
-    return { allowed: false, reason: 'URL 不能为空' };
-  }
-  let parsed;
   try {
-    parsed = new URL(urlStr);
+    const parsed = new URL(urlStr);
+    const hostname = parsed.hostname.toLowerCase();
+    // SSRFGuard 静态校验只拦截 IP 字面量；`localhost` 域名需在此显式处理（保持原语义）
+    if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
+      if (allowLoopback !== true) {
+        return { allowed: false, reason: 'localhost 被拒绝（未开启 allowLoopback）' };
+      }
+    }
+    const port = parsed.port
+      ? Number.parseInt(parsed.port, 10)
+      : (parsed.protocol.toLowerCase() === 'https:' ? 443 : 80);
+    const guard = new SSRFGuard({
+      allowLoopback: allowLoopback === true,
+      allowedPorts: [80, 443, 8080, 8443, 3000, 5000, port],
+    });
+    return guard.validate(urlStr);
   } catch (e) {
     return { allowed: false, reason: `URL 解析失败：${e.message}` };
   }
-  const protocol = parsed.protocol.toLowerCase();
-  if (protocol !== 'http:' && protocol !== 'https:') {
-    return { allowed: false, reason: `协议 ${protocol} 不允许` };
-  }
-  const hostname = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
-
-  // localhost 特殊处理
-  if (hostname === 'localhost') {
-    return allowLoopback
-      ? { allowed: true }
-      : { allowed: false, reason: 'localhost 被拒绝（未开启 allowLoopback）' };
-  }
-
-  // IPv4 检查
-  const ipMatch = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
-  if (ipMatch) {
-    const octets = [Number(ipMatch[1]), Number(ipMatch[2]), Number(ipMatch[3]), Number(ipMatch[4])];
-    if (octets.some(n => n > 255)) {
-      return { allowed: false, reason: `IP ${hostname} 非法` };
-    }
-    const isLoopback = octets[0] === 127;
-    const isPrivate = octets[0] === 10 ||
-      (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) ||
-      (octets[0] === 192 && octets[1] === 168);
-    const isLinkLocal = octets[0] === 169 && octets[1] === 254;
-    const isReserved = octets[0] === 0;
-
-    if (isLoopback && !allowLoopback) {
-      return { allowed: false, reason: `回环 IP ${hostname} 被拒绝` };
-    }
-    if (isPrivate || isLinkLocal || isReserved) {
-      return { allowed: false, reason: `私有/链路本地/保留 IP ${hostname} 被拒绝` };
-    }
-  }
-  return { allowed: true };
 }
 
 class OpenAIClient extends BaseClient {

package/src/alerting/alert-manager.js

@@ -191,6 +191,12 @@ export class WebhookChannel extends NotificationChannel {
     this.timeoutMs = options.timeoutMs || 5000;
     this.events = options.events || ['triggered', 'acknowledged', 'resolved'];
     this._ssrfGuard = options.ssrfGuard || null;
+    // 2026-10-31 渗透测试 R6 修复：DNS 钉扎。
+    // 2026-11-02 评估收尾：Webhook 是面向外部的 SSRF 暴露面（URL 来自告警通道配置），
+    // 钉扎默认开启（pinDns: false 可显式关闭）——在发起请求前解析并固定目标 IP，
+    // 消除 DNS rebinding TOCTOU 窗口；集群内部传输（raft/replication）因 Docker
+    // 多 A 记录/动态网络环境仍保持 opt-in。
+    this._pinDns = options.pinDns !== false;
   }
 
   /**
@@ -216,10 +222,10 @@ export class WebhookChannel extends NotificationChannel {
       return;
     }
 
-    // SSRF 防护：校验 Webhook URL
+    // SSRF 防护：校验 Webhook URL（2026-10-31 M-04：升级为静态+DNS 深度校验）
     const guard = await this._getSSRFGuard();
     if (guard) {
-      const check = guard.validate(this.url);
+      const check = await guard.validateDeep(this.url);
       if (!check.allowed) {
         this._failedCount++;
         console.warn(`[WebhookChannel] SSRF 阻止 Webhook 请求到 ${this.url}: ${check.reason}`);
@@ -227,6 +233,19 @@ export class WebhookChannel extends NotificationChannel {
       }
     }
 
+    // 2026-10-31 渗透测试 R6 修复：DNS 钉扎（可选，pinDns=true 时启用）
+    // 在发起请求前解析并固定目标 IP，消除「DNS 校验与实际请求之间」的 rebinding TOCTOU。
+    let pinned = null;
+    if (this._pinDns && guard) {
+      try {
+        pinned = await guard.resolvePinnedHost(this.url);
+      } catch (err) {
+        this._failedCount++;
+        console.warn(`[WebhookChannel] SSRF 钉扎失败 ${this.url}: ${err.message}`);
+        return;
+      }
+    }
+
     // 延迟加载 node:http，避免浏览器环境报错
     const http = await import('node:http');
     const https = await import('node:https');
@@ -250,15 +269,28 @@ export class WebhookChannel extends NotificationChannel {
       });
 
       const urlObj = new URL(this.url);
-      const req = client.request(urlObj, {
+      const reqOptions = {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           'Content-Length': Buffer.byteLength(payload),
           'User-Agent': 'pure-js-db-alert-manager/1.0',
+          // DNS 钉扎时保留原始 Host 头（虚拟主机路由）
+          ...(pinned ? { Host: pinned.hostHeader } : {}),
         },
         timeout: this.timeoutMs,
-      }, (res) => {
+      };
+      if (pinned) {
+        // 用已校验的解析 IP 直连；https 设置 servername 维持 SNI 与证书校验
+        reqOptions.hostname = pinned.ip;
+        reqOptions.port = pinned.port;
+        reqOptions.path = urlObj.pathname + urlObj.search;
+        if (urlObj.protocol === 'https:') {
+          reqOptions.servername = pinned.hostname;
+        }
+      }
+
+      const req = client.request(pinned ? reqOptions : urlObj, reqOptions, (res) => {
         res.resume(); // 消费响应体
         if (res.statusCode >= 200 && res.statusCode < 300) {
           this._sentCount++;

package/src/audit/audit-log.js

@@ -231,8 +231,14 @@ export class AuditLog {
       return;
     }
 
+    // 2026-10-31 渗透测试 L-01 修复：seq 必须单调递增。
+    // 原公式 _fileRecordCount + size + 1 在持久化模式下同时累加「文件总记录数」与
+    // 「环形缓冲当前大小」（两者同步增长），导致 seq 每次 +2（1,3,5,...），
+    // 且从文件恢复 N 条后续号为 2N+1，序号语义混乱（黑盒实测）。
+    // 持久化模式以 _fileRecordCount（含恢复记录）为准；纯内存模式无文件，
+    // _fileRecordCount 恒为 0，以 size 为准。
     const record = {
-      seq: this._fileRecordCount + this.size + 1,
+      seq: (this._filePath ? this._fileRecordCount : this.size) + 1,
       timestamp: Date.now(),
       sessionId: this._sessionId,
       userId: entry.userId || null,
@@ -666,6 +672,46 @@ export class AuditLog {
           brokenAt = allRecords.length;
         }
       }
+
+      // P0-9 修复（2026-10-31 渗透测试 M-02）：链外追加检测
+      // anchor 每 _anchorUpdateInterval 条更新一次，文件可能合法地比 anchor 多出若干条
+      // （写入后 anchor 尚未刷新）。这些"额外"行必须是哈希链的合法延续——
+      // 从 anchor 预期最后哈希继续向后逐条校验 prevHash 与自身 hash。
+      // 攻击者在文件末尾追加伪造记录（未正确续链）时在此暴露。
+      // 轮转延续文件（首行跨文件链引用）跳过本检查，避免旋转场景误报。
+      if (fileCount > this._anchorExpectedCount && !this._isContinuedChain()) {
+        try {
+          const content = fs.readFileSync(this._filePath, 'utf8');
+          const lines = content.split('\n').filter(l => l.trim());
+          let prevHashExpected = this._anchorExpectedLastHash;
+          let appendOk = true;
+          for (let i = this._anchorExpectedCount; i < lines.length; i++) {
+            let rec;
+            try {
+              rec = JSON.parse(lines[i]);
+            } catch {
+              appendOk = false;
+              break;
+            }
+            if (rec.prevHash !== prevHashExpected || rec.hash !== this._computeHash(rec)) {
+              appendOk = false;
+              break;
+            }
+            prevHashExpected = rec.hash;
+          }
+          if (!appendOk) {
+            errors.push(
+              `P0-9 检测到链外追加/篡改: anchor 预期 ${this._anchorExpectedCount} 条，文件实际 ${fileCount} 条，` +
+              `额外 ${fileCount - this._anchorExpectedCount} 条记录未通过哈希链延续校验`,
+            );
+            if (brokenAt === null) {
+              brokenAt = allRecords.length;
+            }
+          }
+        } catch (err) {
+          errors.push(`P0-9 读取审计文件失败: ${err.message}`);
+        }
+      }
     }
 
     return {
@@ -1074,10 +1120,15 @@ export class AuditLog {
     }
     if (!fileExists) {
       const anchorResult = await this._readAnchor();
+      const errors = [];
       if (anchorResult.error) {
         console.error(`[AuditLog] recoverFromFile: ${anchorResult.error}`);
+        errors.push(anchorResult.error);
       }
-      return { recovered: 0, errors: [] };
+      // P0-9 修复（2026-10-31 渗透测试 M-02）：双文件均不存在时给出显式告警。
+      // 首次启动属正常；但若此前已写入过审计数据，则历史可能已被静默重置（删除 audit.log + .anchor）。
+      errors.push('审计文件与 anchor 文件均不存在：若这不是首次启动，审计历史可能已被删除');
+      return { recovered: 0, errors };
     }
 
     const errors = [];

package/src/backup/backup-manager.js

@@ -31,6 +31,7 @@
  */
 
 import crypto from 'node:crypto';
+import { resolve, sep } from 'node:path';
 import { VERSION } from '../version.js';
 import { Database } from '../executor/database.js';
 
@@ -65,6 +66,34 @@ export class BackupManager {
       .digest('hex');
   }
 
+  /**
+   * 解析并校验备份文件路径（2026-10-31 渗透测试 M-01 修复）
+   *
+   * 背景：MCP backup_database / restore_database 工具把调用方提供的 filePath
+   * 直接透传给 fs.writeFileSync / fs.readFileSync，构成任意路径写/读面。
+   * 现在若设置了 BACKUP_DIR（或 MCP_BACKUP_DIR）环境变量，则强制备份/恢复文件
+   * 必须落在该目录内（与 FDW_BASE_DIR 的路径白名单语义一致）。
+   *
+   * @param {string} filePath - 调用方提供的路径（绝对或相对）
+   * @returns {string} 解析后的绝对路径
+   * @throws {Error} 越权路径抛错
+   * @private
+   */
+  _resolveBackupPath(filePath) {
+    const resolved = resolve(String(filePath));
+    const backupDir = process.env.BACKUP_DIR || process.env.MCP_BACKUP_DIR;
+    if (backupDir) {
+      const baseDir = resolve(backupDir);
+      if (resolved !== baseDir && !resolved.startsWith(baseDir + sep)) {
+        throw new Error(
+          `备份路径越权: ${filePath} 不在 BACKUP_DIR (${baseDir}) 内。` +
+          '请将备份路径限制在 BACKUP_DIR/MCP_BACKUP_DIR 配置的目录内。',
+        );
+      }
+    }
+    return resolved;
+  }
+
   /**
    * P0-7 修复：验证备份文件的 HMAC
    * @param {string} payload - 备份内容 JSON 字符串（不含 hmac 字段）
@@ -134,6 +163,7 @@ export class BackupManager {
     if (!db) {
       throw new Error('fullBackup 需要传入 db 参数');
     }
+    const resolvedPath = this._resolveBackupPath(filePath);
     const data = this._wal.serializeDatabase(db);
     const lastSeq = await this._wal._currentSeq();
     const backup = {
@@ -149,10 +179,10 @@ export class BackupManager {
     if (hmac) {
       backup.hmac = hmac;
     }
-    fs.writeFileSync(filePath, JSON.stringify(backup, null, 2));
+    fs.writeFileSync(resolvedPath, JSON.stringify(backup, null, 2));
     this._backupHistory.push({
       type: 'full',
-      filePath,
+      filePath: resolvedPath,
       timestamp: backup.timestamp,
       lastSeq: backup.lastSeq,
     });
@@ -170,6 +200,7 @@ export class BackupManager {
    */
   async incrementalBackup(filePath, fromSeq) {
     const fs = await import('fs');
+    const resolvedPath = this._resolveBackupPath(filePath);
     const entries = await this._wal.getEntriesAfter(fromSeq);
     const toSeq = await this._wal._currentSeq();
     const backup = {
@@ -186,10 +217,10 @@ export class BackupManager {
     if (hmac) {
       backup.hmac = hmac;
     }
-    fs.writeFileSync(filePath, JSON.stringify(backup, null, 2));
+    fs.writeFileSync(resolvedPath, JSON.stringify(backup, null, 2));
     this._backupHistory.push({
       type: 'incremental',
-      filePath,
+      filePath: resolvedPath,
       timestamp: backup.timestamp,
       fromSeq,
       toSeq: backup.toSeq,
@@ -207,7 +238,8 @@ export class BackupManager {
    */
   async restore(filePath) {
     const fs = await import('fs');
-    const content = fs.readFileSync(filePath, 'utf-8');
+    const resolvedPath = this._resolveBackupPath(filePath);
+    const content = fs.readFileSync(resolvedPath, 'utf-8');
     const backup = JSON.parse(content);
 
     // P0-7 修复：验证 HMAC
@@ -237,7 +269,8 @@ export class BackupManager {
    */
   async pointInTimeRestore(baseBackupPath, walDirectory, targetTime) {
     const fs = await import('fs');
-    const content = fs.readFileSync(baseBackupPath, 'utf-8');
+    const resolvedBasePath = this._resolveBackupPath(baseBackupPath);
+    const content = fs.readFileSync(resolvedBasePath, 'utf-8');
     const baseBackup = JSON.parse(content);
 
     // P0-7 修复：验证 baseBackup 的 HMAC

package/src/cluster/raft-http-transport.js

@@ -45,6 +45,8 @@ export class RaftHttpTransport {
       allowedPorts: [],
     };
     this._ssrfGuard = null;
+    // 2026-10-31 渗透测试 R6 修复：DNS 钉扎（可选，默认关闭）
+    this._pinDns = options.pinDns === true;
 
     /** @type {RaftNode|null} */
     this._node = null;
@@ -141,10 +143,10 @@ export class RaftHttpTransport {
 
     const fullUrl = `http://${address}${path}`;
 
-    // v1.34.5: SSRF 防护校验目标节点地址
+    // v1.34.5: SSRF 防护校验目标节点地址（2026-10-31 M-04：升级为静态+DNS 深度校验）
     const guard = await this._getSSRFGuard();
     if (guard) {
-      const check = guard.validate(fullUrl);
+      const check = await guard.validateDeep(fullUrl);
       if (!check.allowed) {
         throw new Error(`SSRF 阻止 Raft RPC 到 ${targetId} (${fullUrl}): ${check.reason}`);
       }
@@ -152,14 +154,22 @@ export class RaftHttpTransport {
 
     const body = JSON.stringify(request);
     const url = new URL(fullUrl);
+
+    // 2026-10-31 渗透测试 R6 修复：DNS 钉扎（可选）——用解析 IP 直连，保留 Host 头
+    let pinned = null;
+    if (this._pinDns && guard) {
+      pinned = await guard.resolvePinnedHost(fullUrl);
+    }
+
     const reqOpts = {
-      hostname: url.hostname,
-      port: url.port,
+      hostname: pinned ? pinned.ip : url.hostname,
+      port: pinned ? pinned.port : url.port,
       path: url.pathname,
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
         'Content-Length': Buffer.byteLength(body),
+        ...(pinned ? { Host: pinned.hostHeader } : {}),
       },
       timeout: this.timeout,
     };

package/src/executor/executor.js

@@ -9731,7 +9731,22 @@ export class Executor {
    */
   enableAuditLog(options = {}) {
     this._auditLog = new AuditLog(options);
-    this._auditLog.enable();
+    // 2026-10-31 渗透测试 M-02 修复：将恢复结果（含 anchor 缺失/历史可能被删除等告警）
+    // 通过 console.warn 暴露给运维；原实现静默吞掉 errors，导致删除审计文件不被察觉。
+    const enableResult = this._auditLog.enable();
+    if (enableResult && typeof enableResult.then === 'function') {
+      enableResult
+        .then((result) => {
+          const errs = result?.errors || [];
+          if (errs.length > 0) {
+            console.warn(`[AuditLog] 恢复警告（${errs.length} 项）:`);
+            for (const e2 of errs) console.warn(`  - ${e2}`);
+          }
+        })
+        .catch((err) => {
+          console.warn(`[AuditLog] 启用审计失败: ${err?.message || err}`);
+        });
+    }
     return this._auditLog;
   }
 
@@ -10386,6 +10401,14 @@ export class Executor {
       }
     }
     const result = this.executeSQL(sql, params, options);
+    // 2026-10-31 渗透测试 C-01 修复：并行 SELECT 路径（autoParallel + WorkerPool）使
+    // executeSQL 返回 Promise.all(...)。若此 Promise 在下方 setImmediate 让出期间拒绝，
+    // 且尚未挂接任何 handler，Node 会触发 unhandledRejection 默认致命错误，直接崩溃进程。
+    // 这里在让出前立即挂接一个 no-op catch（标记为已处理，不影响 return 采纳原始状态），
+    // 避免服务被任意 SELECT 运行时错误（缺表/缺列/类型错误）远程打崩。
+    if (result && typeof result.then === 'function') {
+      result.catch(() => { /* 仅标记已处理，错误仍由调用方 await 观察到 */ });
+    }
     // 执行后让出：结果返回前事件循环有机会处理新到达的请求
     await new Promise((resolve) => setImmediate(resolve));
     return result;