pure-js-db 2.53.0 → 2.53.1

package/src/executor/wal.js

@@ -53,6 +53,7 @@
 import { Database, Table, ColumnDef } from './database.js';
 import { MemoryKVAdapter } from '../storage/kv-adapter.js';
 import { computeCRC32, assertSafeSeq } from '../utils/wal-common.js';
+import crypto from 'node:crypto';
 
 const WAL_KEY_PREFIX = 'db:wal';
 const CP_KEY_PREFIX = 'db:checkpoint';
@@ -98,6 +99,18 @@ function hexToBytes(hex) {
   return bytes;
 }
 
+/**
+ * 计算十六进制字符串的 HMAC-SHA256（2026-10-31 渗透测试 M-03 修复）
+ * @param {string} valueHex - 待认证的十六进制内容
+ * @param {string} key - HMAC 密钥
+ * @returns {string} 十六进制 HMAC
+ */
+function hmacHex(valueHex, key) {
+  return crypto.createHmac('sha256', Buffer.from(key, 'utf8'))
+    .update(valueHex, 'utf8')
+    .digest('hex');
+}
+
 // ═══════════════════════════════════════════
 // 二进制 WAL 批次格式
 // ═══════════════════════════════════════════
@@ -143,9 +156,10 @@ const OP_TO_NAME = {
 /**
  * 将 WAL 条目数组序列化为二进制批次
  * @param {Object[]} entries
- * @returns {string} 十六进制字符串
+ * @param {string} [hmacKey] - 可选 HMAC 密钥；设置后返回 `${hex}.${hmac}` 后缀
+ * @returns {string} 十六进制字符串（配置 hmacKey 时含 `.hmac` 后缀）
  */
-function serializeBatch(entries) {
+function serializeBatch(entries, hmacKey) {
   // P1-F 修复 v1.34.2：批次条目数 >65535 时旧格式（count 2B）会静默截断
   // 抛出错误而非截断，让调用方感知 bug（groupCommitMaxEntries 默认 64，不应触发）
   // 注意：上层 _flushBatch 已按 MAX_ENTRIES_PER_BATCH 拆分，正常不应触达此守卫。
@@ -238,7 +252,11 @@ function serializeBatch(entries) {
   const crc = crc32(crcBuf);
   fullView.setUint32(8, crc, false);
 
-  return bytesToHex(fullBuf);
+  const hex = bytesToHex(fullBuf);
+  if (hmacKey) {
+    return `${hex}.${hmacHex(hex, hmacKey)}`;
+  }
+  return hex;
 }
 
 /**
@@ -246,11 +264,36 @@ function serializeBatch(entries) {
  * @param {string} hex
  * @param {number} batchSeq
  * @param {function} [reportWarn] - 可选，告警回调 ({ level, message, context })
+ * @param {string} [hmacKey] - 可选 HMAC 密钥；设置后校验批次 HMAC（不匹配返回 null）
  * @returns {{ seq: number, entries: Object[] }|null}
  */
-function deserializeBatch(hex, batchSeq, reportWarn) {
+function deserializeBatch(hex, batchSeq, reportWarn, hmacKey) {
   try {
-    const buf = hexToBytes(hex);
+    // 2026-10-31 渗透测试 M-03 修复：分离并校验 HMAC 后缀（`.hmacHex`）
+    let batchHex = hex;
+    let storedHmac = null;
+    const dotIdx = hex.indexOf('.');
+    if (dotIdx !== -1) {
+      batchHex = hex.slice(0, dotIdx);
+      storedHmac = hex.slice(dotIdx + 1);
+    }
+    if (hmacKey) {
+      if (storedHmac) {
+        const expectedHmac = hmacHex(batchHex, hmacKey);
+        if (expectedHmac !== storedHmac) {
+          const warnMsg = 'Batch HMAC mismatch（WAL 可能被篡改）';
+          if (reportWarn) reportWarn('warn', warnMsg);
+          else console.warn(`[WAL] ${warnMsg}`);
+          return null;
+        }
+      } else {
+        // 旧格式（无 HMAC 后缀）：向后兼容放行，但提示未受认证完整性保护
+        const warnMsg = 'Batch 缺少 HMAC（旧格式 WAL，未受认证完整性保护）';
+        if (reportWarn) reportWarn('warn', warnMsg);
+        else console.warn(`[WAL] ${warnMsg}`);
+      }
+    }
+    const buf = hexToBytes(batchHex);
     if (buf.length < BATCH_HEADER_SIZE) {
       return null;
     }
@@ -350,6 +393,12 @@ export class WriteAheadLog {
     this._seqInitialized = false; // 懒初始化标记
     this._seq = 0;
 
+    // 2026-10-31 渗透测试 M-03 修复：可选 WAL/checkpoint 认证完整性密钥。
+    // 设置 hmacKey 后，新写入的二进制批次与 checkpoint 均附加 HMAC-SHA256；
+    // 恢复时校验 HMAC（不匹配则拒绝该批次/快照）。旧格式（无 HMAC）仍可读取
+    // （向后兼容），但会告警提示。
+    this._hmacKey = options.hmacKey || null;
+
     // ── 历史 checkpoint 保留策略（P3-#17） ──
     /** @type {boolean} 保留所有历史 checkpoint（时间旅行查询必需） */
     this._keepAllCps = options.keepAllCheckpoints === true;
@@ -572,7 +621,7 @@ export class WriteAheadLog {
         continue;
       }
 
-      const result = deserializeBatch(raw, batchSeq, this._reportError.bind(this));
+      const result = deserializeBatch(raw, batchSeq, this._reportError.bind(this), this._hmacKey);
       if (!result || !result.entries) {
         continue;
       }
@@ -866,9 +915,16 @@ export class WriteAheadLog {
     const cpKey = `${CP_KEY_PREFIX}:${this.dbName}:${String(seq).padStart(16, '0')}`;
     const tmpKey = cpKey + ':tmp'; // 临时键，用于原子切换
 
+    // 2026-10-31 渗透测试 M-03 修复：配置 hmacKey 时为 checkpoint 附加 HMAC 认证
+    let cpJson = JSON.stringify(cpData);
+    if (this._hmacKey) {
+      const hmac = hmacHex(cpJson, this._hmacKey);
+      cpJson = JSON.stringify({ ...cpData, _hmac: hmac });
+    }
+
     try {
       // 阶段 1：写入临时 checkpoint
-      await this.kv.set(tmpKey, JSON.stringify(cpData));
+      await this.kv.set(tmpKey, cpJson);
       if (typeof this.kv.flush === 'function') {
         await this.kv.flush();
       }
@@ -1128,7 +1184,7 @@ export class WriteAheadLog {
         for (let offset = 0; offset < entries.length; offset += chunkSize) {
           const chunk = entries.slice(offset, offset + chunkSize);
           const chunkStartSeq = startSeq + offset;
-          const hex = serializeBatch(chunk);
+          const hex = serializeBatch(chunk, this._hmacKey);
           const key = `${WAL_KEY_PREFIX}:${this.dbName}:seq:${String(chunkStartSeq).padStart(16, '0')}`;
           await this.kv.set(key, hex);
         }
@@ -1268,10 +1324,10 @@ export class WriteAheadLog {
         continue;
       }
 
-      // 尝试二进制批次格式（十六进制字符串）
-      if (/^[0-9a-f]+$/i.test(raw) && raw.length > 20) {
+      // 尝试二进制批次格式（十六进制字符串；2026-10-31 起可带 `.hmac` 认证后缀）
+      if (/^[0-9a-f]+(\.[0-9a-f]+)?$/i.test(raw) && raw.length > 20) {
         const keySeq = parseInt(key.split(':').pop(), 10) || 0;
-        const result = deserializeBatch(raw, keySeq, this._reportError.bind(this));
+        const result = deserializeBatch(raw, keySeq, this._reportError.bind(this), this._hmacKey);
         if (result && result.entries) {
           for (const entry of result.entries) {
             if (entry.seq > afterSeq) {
@@ -1331,6 +1387,20 @@ export class WriteAheadLog {
       return 0;
     }
 
+    // 2026-10-31 渗透测试 M-03 修复：校验 checkpoint HMAC（若配置密钥）
+    if (this._hmacKey) {
+      if (cpData && typeof cpData === 'object' && '_hmac' in cpData) {
+        const { _hmac, ...payloadObj } = cpData;
+        const expectedHmac = hmacHex(JSON.stringify(payloadObj), this._hmacKey);
+        if (expectedHmac !== _hmac) {
+          this._reportError('warn', `_loadCheckpoint: checkpoint HMAC mismatch (可能被篡改), skipping "${latestKey}"`);
+          return 0;
+        }
+      } else {
+        this._reportError('warn', `_loadCheckpoint: checkpoint 缺少 HMAC（旧格式快照，未受认证完整性保护）`);
+      }
+    }
+
     // 还原表
     for (const [tableName, tableMeta] of Object.entries(cpData.tables)) {
       const colDefs = tableMeta.columns.map(c =>

package/src/graphql-bridge.js

@@ -337,9 +337,50 @@ class Parser {
 export class GraphQLBridge {
   /**
    * @param {object} executor - Executor 实例
+   * @param {object} [options]
+   * @param {number} [options.maxDepth=8] - 最大查询嵌套深度（防深度炸弹）
+   * @param {number} [options.maxSelections=100] - 单请求最大字段/选择数（防字段数放大）
    */
-  constructor(executor) {
+  constructor(executor, options = {}) {
     this.executor = executor;
+    this.maxDepth = Number.isFinite(options.maxDepth) ? options.maxDepth : 8;
+    this.maxSelections = Number.isFinite(options.maxSelections) ? options.maxSelections : 100;
+  }
+
+  /**
+   * 校验查询成本（2026-10-31 渗透测试 R7 修复）
+   *
+   * 递归遍历 AST，统计最大嵌套深度与总选择（字段）数。
+   * 超限直接抛错，防止深度嵌套/海量字段的解析与执行放大 DoS。
+   * @param {{operation: string, selections: Array}} doc - parseDocument 返回的 AST
+   * @private
+   */
+  _validateQueryCost(doc) {
+    let totalSelections = 0;
+    let maxDepth = 0;
+
+    const walk = (fields, depth) => {
+      if (depth > maxDepth) {
+        maxDepth = depth;
+      }
+      if (!fields || fields.length === 0) {
+        return;
+      }
+      for (const f of fields) {
+        totalSelections++;
+        if (totalSelections > this.maxSelections) {
+          throw new Error(`GraphQL 查询字段数超过上限 ${this.maxSelections}（防资源耗尽）`);
+        }
+        if (f.fields && f.fields.length > 0) {
+          walk(f.fields, depth + 1);
+        }
+      }
+    };
+
+    walk(doc.selections, 1);
+    if (maxDepth > this.maxDepth) {
+      throw new Error(`GraphQL 查询深度 ${maxDepth} 超过上限 ${this.maxDepth}（防嵌套 DoS）`);
+    }
   }
 
   /**
@@ -456,6 +497,9 @@ ${mutationFields.join('\n')}
       const parser = new Parser(tokens);
       const doc = parser.parseDocument();
 
+      // 2026-10-31 渗透测试 R7 修复：查询成本上限（深度/字段数）
+      this._validateQueryCost(doc);
+
       if (doc.operation === 'mutation') {
         return this._executeMutations(doc.selections);
       }

package/src/http-api.js

@@ -207,6 +207,16 @@ function _containsSubquery(expr) {
  */
 function parseBody(req, limit = 1048576) {
   return new Promise((resolve, reject) => {
+    // 2026-10-31 渗透测试 H-03 修复：拒绝非 JSON Content-Type（消除跨站盲写 SQL 面），
+    // 与 http-server/server.js parseBody 行为对齐。
+    const contentType = (req.headers['content-type'] || '').toLowerCase();
+    if (contentType && !contentType.includes('application/json')) {
+      // 排空 body 但不销毁连接，让 handler 正常返回 400 错误响应
+      req.removeAllListeners('data');
+      req.resume();
+      reject(new Error('不支持的 Content-Type：仅接受 application/json'));
+      return;
+    }
     let body = '';
     let totalBytes = 0;
     req.on('data', chunk => {
@@ -229,6 +239,26 @@ function parseBody(req, limit = 1048576) {
   });
 }
 
+/**
+ * 认证端点安全错误文案（2026-10-31 渗透测试 L-05 修复）
+ *
+ * AuthManager 已把所有可预期失败归一为安全文案（反用户枚举）；
+ * 但非预期异常（数据库故障、TypeError 等）可能携带内部细节。
+ * 这里仅透出白名单内的业务文案，其余统一为通用信息（dev 模式保留细节便于排查）。
+ * @param {Error} err
+ * @returns {string}
+ */
+function safeAuthError(err) {
+  const msg = err?.message || '';
+  const isDev = process.env.NODE_ENV === 'development';
+  if (msg === '注册失败' || msg === '用户名或密码错误' ||
+      msg === 'username 与 password 不能为空' || msg === '用户不存在' ||
+      msg === '旧密码错误') {
+    return msg;
+  }
+  return isDev ? msg : '认证服务异常，请稍后重试';
+}
+
 /**
  * 统一错误响应（2026-08-14 M-06 修复：默认隐藏内部错误细节，防信息泄露）
  * - NODE_ENV=development 时保留 err.message 便于调试
@@ -924,7 +954,7 @@ export class HttpApiServer {
       res.end(JSON.stringify(result));
     } catch (err) {
       res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message }));
+      res.end(JSON.stringify({ error: safeAuthError(err) }));
     }
   }
 
@@ -955,7 +985,7 @@ export class HttpApiServer {
       }
     } catch (err) {
       res.writeHead(401, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message }));
+      res.end(JSON.stringify({ error: safeAuthError(err) }));
     }
   }
 

package/src/http-server/index.js

@@ -32,6 +32,7 @@ export { DBServer };
  * @param {string}   [options.signingKey]        - RSA 私钥 PEM（v1.12.0 数字签名）
  * @param {string}   [options.verifyKey]         - RSA 公钥 PEM（v1.12.0 签名验证）
  * @param {string}   [options.auditFilePath]     - 审计日志持久化文件路径
+ * @param {string}   [options.anchorSigningKey]   - 持久化审计 anchor HMAC 密钥（≥32 字节；配置 auditFilePath 时必填，M-5/fail-closed）
  * @param {boolean}  [options.enableAuditOnStart=true] - 启动时自动启用审计日志
  * @param {string[]} [options.corsOrigins]       - v1.34.6: CORS 允许的 Origin 白名单（null 或含 '*' 表示允许任意）
  * @param {boolean}  [options.trustUserIdHeader=false] - v1.34.6: 是否信任 X-User-Id 头部作为身份来源（默认 false，仅受信反代场景开启）
@@ -79,6 +80,7 @@ export async function startHTTPServer(executor, options = {}) {
     signingKey: options.signingKey,
     verifyKey: options.verifyKey,
     auditFilePath: options.auditFilePath,
+    anchorSigningKey: options.anchorSigningKey,
     enableAuditOnStart: options.enableAuditOnStart,
     corsOrigins: options.corsOrigins,
     trustUserIdHeader: options.trustUserIdHeader,

package/src/http-server/server.js

@@ -304,6 +304,19 @@ export function parseBody(req, limit = DEFAULT_BODY_LIMIT) {
     const chunks = [];
     let totalBytes = 0;
 
+    // 2026-10-31 渗透测试 H-03 修复：拒绝非 JSON Content-Type。
+    // 浏览器跨站"简单请求"（text/plain 等）此前可带 JSON body 盲执行 SQL；
+    // 现在仅接受 application/json，浏览器跨站 application/json 会触发 CORS preflight
+    // （默认被 CORS 'null' 策略拒绝），从而消除 CSRF 盲写面。
+    const contentType = (req.headers['content-type'] || '').toLowerCase();
+    if (contentType && !contentType.includes('application/json')) {
+      // 排空 body 但不销毁连接，让 handler 正常返回 400 错误响应
+      req.removeAllListeners('data');
+      req.resume();
+      reject(new Error('不支持的 Content-Type：仅接受 application/json'));
+      return;
+    }
+
     req.on('data', chunk => {
       totalBytes += chunk.length;
       if (totalBytes > limit) {

package/src/http-server/ws-server.js

@@ -657,14 +657,18 @@ export class WSServer {
 
   /**
    * Origin 校验（M-04 修复）：配置白名单后，浏览器 Origin 必须精确匹配
+   * 2026-10-31 渗透测试 L-03 收紧扣紧：未配置白名单时（零认证回环模式），
+   * 仍拒绝携带 Origin 的浏览器连接（跨站 WebSocket 劫持面），仅放行无 Origin
+   * 的非浏览器客户端（curl/Node SDK）。
    * @param {string|null} origin
    * @returns {boolean}
    * @private
    */
   _checkOrigin(origin) {
     if (!this._allowedOrigins) {
-      return true;
-    } // 未配置白名单：放行
+      // 未配置白名单：仅允许无 Origin 的非浏览器客户端（浏览器必然携带 Origin）
+      return !origin;
+    }
     if (!origin) {
       return this._allowNoOrigin;
     } // 无 Origin：非浏览器客户端

package/src/replication/replication-http-transport.js

@@ -292,6 +292,8 @@ export class ReplicaHttpClient {
       allowedPorts: [],
     };
     this._ssrfGuard = null;
+    // 2026-10-31 渗透测试 R6 修复：DNS 钉扎（可选，默认关闭）
+    this._pinDns = options.pinDns === true;
   }
 
   /**
@@ -347,11 +349,11 @@ export class ReplicaHttpClient {
   }
 
   async _request(method, path, request) {
-    // v1.34.5: SSRF 防护校验主节点地址
+    // v1.34.5: SSRF 防护校验主节点地址（2026-10-31 M-04：升级为静态+DNS 深度校验）
     const fullUrl = `http://${this.masterHost}:${this.masterPort}${path}`;
     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 阻止主节点请求: ${check.reason}`);
       }
@@ -362,6 +364,12 @@ export class ReplicaHttpClient {
       body = JSON.stringify(request);
     }
 
+    // 2026-10-31 渗透测试 R6 修复：DNS 钉扎（可选）——用解析 IP 直连，保留 Host 头
+    let pinned = null;
+    if (this._pinDns && guard) {
+      pinned = await guard.resolvePinnedHost(fullUrl);
+    }
+
     const headers = {
       'Content-Type': 'application/json',
     };
@@ -369,10 +377,14 @@ export class ReplicaHttpClient {
     if (this._authToken) {
       headers['Authorization'] = `Bearer ${this._authToken}`;
     }
+    // DNS 钉扎时保留原始 Host 头
+    if (pinned) {
+      headers.Host = pinned.hostHeader;
+    }
 
     const reqOpts = {
-      hostname: this.masterHost,
-      port: this.masterPort,
+      hostname: pinned ? pinned.ip : this.masterHost,
+      port: pinned ? pinned.port : this.masterPort,
       path,
       method,
       headers,

package/src/sdk/java/pom.xml

@@ -7,7 +7,7 @@
 
   <groupId>com.purejsdb</groupId>
   <artifactId>pure-client</artifactId>
-  <version>2.53.0</version>
+  <version>2.53.1</version>
   <packaging>jar</packaging>
 
   <name>pure-js-db Java SDK</name>

package/src/sdk/java/pureclient/PureClient.java

@@ -62,7 +62,7 @@ import java.util.NoSuchElementException;
 public class PureClient {
 
     /** SDK 版本号。 */
-    public static final String SDK_VERSION = "2.53.0";
+    public static final String SDK_VERSION = "2.53.1";
 
     /** 默认请求超时（秒）。 */
     public static final long DEFAULT_TIMEOUT_SECONDS = 30;

package/src/sdk/java/pureclient/PureClientTest.java

@@ -114,7 +114,7 @@ class PureClientTest {
     @Order(1)
     @DisplayName("J1: SDK 版本号应为 1.10.0")
     void testSdkVersion() {
-        assertEquals("2.53.0", PureClient.SDK_VERSION,
+        assertEquals("2.53.1", PureClient.SDK_VERSION,
                 "SDK 版本应为 1.10.0");
     }
 

package/src/sdk/php/composer.json

@@ -2,7 +2,7 @@
     "name": "pure-js-db/php-sdk",
     "description": "PHP SDK for pure-js-db — pure JavaScript database engine, via HTTP RESTful API.",
     "type": "library",
-    "version": "2.53.0",
+    "version": "2.53.1",
     "keywords": ["database", "sdk", "pure-js-db", "rest", "curl"],
     "license": "MIT",
     "require": {

package/src/sdk/php/src/PureClient.php

@@ -34,7 +34,7 @@ namespace PureJSDB\Sdk;
 class PureClient
 {
     /** @var string SDK 版本号 */
-    public const SDK_VERSION = '2.53.0';
+    public const SDK_VERSION = '2.53.1';
 
     /** @var float 默认请求超时（秒） */
     private const DEFAULT_TIMEOUT = 30.0;

package/src/sdk/python/pure_client.py

@@ -35,7 +35,7 @@ import urllib.parse
 from typing import Any, Dict, Iterator, List, Optional, Union
 
 
-__version__ = "2.53.0"
+__version__ = "2.53.1"
 
 
 class PureError(Exception):

package/src/sdk/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pure-js-db"
-version = "2.53.0"
+version = "2.53.1"
 edition = "2021"
 rust-version = "1.75"
 description = "Rust SDK for pure-js-db — HTTP RESTful API 客户端 + HNSWPQ 向量索引管理"

package/src/sdk/rust/RELEASE-CHECKLIST.md

@@ -29,8 +29,8 @@ grep -E 'SDK 版本：\*\*[0-9]+\.[0-9]+\.[0-9]+\*\*' README.md  # 期望: SDK
 
 | 文件 | 当前值 |
 |------|--------|
-| `pure-js-db/package.json` | `2.53.0` |
-| `pure-js-db/src/index.js` `VERSION` | `'2.53.0'` |
+| `pure-js-db/package.json` | `2.53.1` |
+| `pure-js-db/src/index.js` `VERSION` | `'2.53.1'` |
 
 ---
 

package/src/sdk/rust/src/lib.rs

@@ -57,7 +57,7 @@ pub use models::{
 pub use transaction::Transaction;
 
 /// SDK 版本号
-pub const SDK_VERSION: &str = "2.53.0";
+pub const SDK_VERSION: &str = "2.53.1";
 
 /// 默认 API 前缀
 pub const DEFAULT_API_PREFIX: &str = "/api/v1";