chanjs 2.7.4 → 2.7.6

package/security/sign.js

@@ -1,210 +1,117 @@
-import crypto from "crypto";
-
 /**
- * 加密和签名工具函数
- * 提供安全的 AES-256-GCM 加密解密和 HMAC-SHA256 数据签名
- *
- * 安全改进：
- * 1. 弃用 CryptoJS（默认用 EVP_BytesToKey 派生密钥，安全性不足）
- * 2. 改用 Node.js 原生 crypto 模块，AES-256-GCM 提供机密性 + 完整性
- * 3. 密钥派生用 scrypt（抗暴力破解，NIST 推荐）
- * 4. verifySign 用 crypto.timingSafeEqual 替换 ===，防止时序攻击
- *
- * 兼容性说明：
- * - 新版 AES 密文格式：base64(iv:tag:ciphertext)，与 CryptoJS 不兼容
- * - 旧版 Cookie 失效后业务层 catch 会自动重新生成（Share.js 已处理）
+ * AES-256-GCM 加解密工具，内置scrypt密钥派生+LRU缓存
  */
+import crypto from "node:crypto";
+import logger from "../utils/logger.js";
+
+const AES_CFG = Object.freeze({
+  ALG: "aes-256-gcm",
+  IV_LEN: 12,
+  TAG_LEN: 16,
+  KEY_BYTES: 32,
+  SCRYPT_N: 16384,
+  SCRYPT_R: 8,
+  SCRYPT_P: 1,
+  CACHE_MAX: 100,
+});
 
-/**
- * 密钥派生缓存（避免每次加解密都派生一遍）
- * 改为 LRU：命中时先 delete 再 set，刷新访问顺序
- */
 const keyCache = new Map();
-const KEY_CACHE_MAX = 100;
+let saltWarnFlag = false;
 
 /**
- * 从用户密钥派生固定长度的 AES-256 密钥
- * 用 scrypt 算法，参数选择 N=16384, r=8, p=1，约 100ms 派生时间，抗暴力破解
- *
- * 安全改进：
- * - salt 优先用 AES_SALT 环境变量（部署期固定），不再从 secret 推导
- * - 未设置 AES_SALT 时降级到原行为并打印警告
- * @private
+ * scrypt派生32字节AES密钥，带LRU缓存复用
+ * @param {string} secret
+ * @returns {Promise<Buffer|null>}
  */
-function deriveKey(secret) {
-  if (!secret || typeof secret !== 'string') return null;
+const deriveKey = async secret => {
+  if (!secret || typeof secret !== "string") return null;
+
+  // LRU 命中
   if (keyCache.has(secret)) {
-    // LRU 命中：先 delete 再 set，刷新到 Map 末尾
-    const cached = keyCache.get(secret);
+    const buf = keyCache.get(secret);
     keyCache.delete(secret);
-    keyCache.set(secret, cached);
-    return cached;
+    keyCache.set(secret, buf);
+    return buf;
   }
 
-  // salt 优先用 AES_SALT 环境变量；未配置时降级到 secret 哈希
-  const aesSalt = process.env.AES_SALT;
+  // 派生盐：环境变量优先，否则警告并用 secret 派生
   let salt;
-  if (aesSalt) {
-    salt = crypto.createHash('sha256').update(aesSalt).digest();
+  if (process.env.AES_SALT) {
+    salt = crypto.createHash("sha256").update(process.env.AES_SALT).digest();
   } else {
-    if (!deriveKey._warned) {
-      console.warn('[安全警告] 未配置 AES_SALT 环境变量，回退到基于 secret 的 salt，建议设置 AES_SALT');
-      deriveKey._warned = true;
+    if (!saltWarnFlag) {
+      logger.warn("[安全警告] 未配置环境变量 AES_SALT，建议统一配置固定盐值");
+      saltWarnFlag = true;
     }
-    salt = crypto.createHash('sha256').update(secret).digest();
+    salt = crypto.createHash("sha256").update(secret).digest();
   }
-  const key = crypto.scryptSync(secret, salt, 32);  // AES-256 需要 32 字节密钥
 
-  // LRU 缓存上限：超过时淘汰 Map 头部（最久未访问）
-  if (keyCache.size >= KEY_CACHE_MAX) {
-    const oldestKey = keyCache.keys().next().value;
-    if (oldestKey !== undefined) keyCache.delete(oldestKey);
+  // scrypt 异步派生
+  const keyBuf = await new Promise((resolve, reject) => {
+    crypto.scrypt(secret, salt, AES_CFG.KEY_BYTES, {
+      N: AES_CFG.SCRYPT_N, r: AES_CFG.SCRYPT_R, p: AES_CFG.SCRYPT_P,
+    }, (err, derivedKey) => err ? reject(err) : resolve(derivedKey));
+  });
+
+  // LRU 淘汰
+  if (keyCache.size >= AES_CFG.CACHE_MAX) {
+    const oldest = keyCache.keys().next().value;
+    if (oldest !== undefined) keyCache.delete(oldest);
   }
-  keyCache.set(secret, key);
-  return key;
-}
+  keyCache.set(secret, keyBuf);
+  return keyBuf;
+};
 
 /**
- * AES 加密（AES-256-GCM）
- * @param {Object|string} obj - 要加密的对象或字符串
- * @param {string} key - 加密密钥（用户提供的密钥，会通过 scrypt 派生）
- * @returns {string|null} 加密后的字符串（base64 编码，格式：iv:tag:ciphertext），失败时返回 null
- * @description
- * 使用 AES-256-GCM 算法加密数据
- * - GCM 模式提供机密性 + 完整性校验
- * - 每次加密生成随机 IV（12 字节），防止相同明文产生相同密文
- * - 输出格式：base64(iv + tag + ciphertext)
- * @example
- * const encrypted = aesEncrypt({ id: 1, name: '张三' }, 'my-secret-key');
+ * AES加密：输出iv+tag+密文合并base64
+ * @param {string|object} data
+ * @param {string} secret
+ * @returns {Promise<string|null>}
  */
-export const aesEncrypt = (obj, key) => {
-  if (!key) {
-    console.error('[安全错误] AES_SALT 必须配置');
-    return null;
-  }
+export const aesEncrypt = async (data, secret) => {
+  if (!secret) return logger.error("[安全错误] 加密密钥secret不能为空"), null;
   try {
-    const derivedKey = deriveKey(key);
-    if (!derivedKey) return null;
-
-    // 随机 IV（12 字节，GCM 推荐长度）
-    const iv = crypto.randomBytes(12);
-    const cipher = crypto.createCipheriv('aes-256-gcm', derivedKey, iv);
-
-    const plaintext = typeof obj === 'string' ? obj : JSON.stringify(obj);
-    const encrypted = Buffer.concat([
-      cipher.update(plaintext, 'utf8'),
-      cipher.final(),
-    ]);
-    const tag = cipher.getAuthTag();  // 16 字节认证标签
-
-    // 格式：base64(iv + tag + ciphertext)
-    return Buffer.concat([iv, tag, encrypted]).toString('base64');
-  } catch (error) {
-    console.error("AES加密失败:", error.message);
+    const key = await deriveKey(secret);
+    if (!key) return null;
+
+    const iv = crypto.randomBytes(AES_CFG.IV_LEN);
+    const cipher = crypto.createCipheriv(AES_CFG.ALG, key, iv);
+    const plain = typeof data === "string" ? data : JSON.stringify(data);
+
+    const cipherBuf = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, tag, cipherBuf]).toString("base64");
+  } catch (err) {
+    logger.error("AES加密失败", err.message);
     return null;
   }
 };
 
 /**
- * AES 解密（AES-256-GCM）
- * @param {string} str - 要解密的字符串（base64 编码，格式：iv:tag:ciphertext）
- * @param {string} key - 解密密钥
- * @returns {string|null} 解密后的字符串，失败时返回 null
- * @description
- * 使用 AES-256-GCM 算法解密数据
- * - 自动校验 GCM 认证标签，密文被篡改会抛错
- * - 与 aesEncrypt 配对使用
- * @example
- * const decrypted = aesDecrypt(encryptedStr, 'my-secret-key');
+ * AES解密，校验GCM完整性tag防篡改
+ * @param {string} base64Str
+ * @param {string} secret
+ * @returns {Promise<string|null>}
  */
-export const aesDecrypt = (str, key) => {
-  if (!key) {
-    console.error('[安全错误] AES_SALT 必须配置');
-    return null;
-  }
+export const aesDecrypt = async (base64Str, secret) => {
+  if (!secret) return logger.error("[安全错误] 解密密钥secret不能为空"), null;
   try {
-    const derivedKey = deriveKey(key);
-    if (!derivedKey) return null;
+    const key = await deriveKey(secret);
+    if (!key) return null;
 
-    const data = Buffer.from(str, 'base64');
-    // 前 12 字节是 IV，接下来 16 字节是 GCM tag，剩下是密文
-    if (data.length < 28) return null;  // 12 + 16 最小长度
-    const iv = data.subarray(0, 12);
-    const tag = data.subarray(12, 28);
-    const ciphertext = data.subarray(28);
+    const raw = Buffer.from(base64Str, "base64");
+    const minLen = AES_CFG.IV_LEN + AES_CFG.TAG_LEN;
+    if (raw.length < minLen) return null;
 
-    const decipher = crypto.createDecipheriv('aes-256-gcm', derivedKey, iv);
-    decipher.setAuthTag(tag);
+    const iv = raw.subarray(0, AES_CFG.IV_LEN);
+    const tag = raw.subarray(AES_CFG.IV_LEN, minLen);
+    const cipherBuf = raw.subarray(minLen);
 
-    const decrypted = Buffer.concat([
-      decipher.update(ciphertext),
-      decipher.final(),
-    ]);
-    return decrypted.toString('utf8');
-  } catch (error) {
-    console.error("AES解密失败:", error.message);
+    const decipher = crypto.createDecipheriv(AES_CFG.ALG, key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(cipherBuf), decipher.final()]).toString("utf8");
+  } catch (err) {
+    logger.error("AES解密失败", err.message);
     return null;
   }
 };
-
-/**
- * 数据签名（HMAC-SHA256）
- * @param {Object} data - 要签名的数据对象
- * @param {string} secret - 签名密钥
- * @returns {string|null} 签名字符串（hex 编码），失败时返回 null
- * @description
- * 使用 HMAC-SHA256 算法对数据进行签名
- * 原生 crypto 实现，与 CryptoJS.HmacSHA256 输出格式兼容（hex 字符串）
- * @example
- * const signature = signData({ userId: 123 }, 'my-sign-key');
- */
-export function signData(data, secret) {
-  if (!secret) {
-    console.error('[安全错误] 签名密钥必须配置');
-    return null;
-  }
-  try {
-    const hmac = crypto.createHmac('sha256', secret);
-    hmac.update(JSON.stringify(data));
-    return hmac.digest('hex');
-  } catch (error) {
-    console.error("数据签名失败:", error.message);
-    return null;
-  }
-}
-
-/**
- * 验证数据签名
- * @param {Object} data - 原始数据对象
- * @param {string} signature - 待验证的签名
- * @param {string} secret - 签名密钥
- * @returns {boolean} 签名是否有效
- * @description
- * 重新计算签名并使用 crypto.timingSafeEqual 进行常量时间比对
- * 防止时序攻击：攻击者无法通过响应时间推断签名前缀
- *
- * 安全要点：
- * 1. 两边长度不同直接返回 false（不进入 timingSafeEqual，避免越界）
- * 2. 长度相同才用 timingSafeEqual 进行常量时间比较
- * 3. 返回值不抛异常，只返回 true/false
- * @example
- * const isValid = verifySign({ userId: 123 }, signature, 'my-sign-key');
- */
-export function verifySign(data, signature, secret) {
-  try {
-    const computedSign = signData(data, secret);
-    if (!computedSign || !signature) return false;
-
-    // 长度不同直接返回 false（timingSafeEqual 要求两边等长）
-    if (computedSign.length !== signature.length) return false;
-
-    // 常量时间比较，防止时序攻击
-    return crypto.timingSafeEqual(
-      Buffer.from(computedSign),
-      Buffer.from(String(signature))
-    );
-  } catch (error) {
-    console.error("签名验证失败:", error.message);
-    return false;
-  }
-}

package/security/xss-filter.js

@@ -1,63 +1,31 @@
-import xss from 'xss';
+import xss from "xss";
 
 /**
- * XSS 过滤工具
- * 提供跨站脚本攻击过滤功能
+ * 递归深度过滤对象/数组/字符串XSS，WeakSet防循环引用栈溢出
+ * @param {any} data 待清洗数据
+ * @param {WeakSet} [visited] 循环引用标记缓存
+ * @returns {any} 清洗后数据
  */
+export const filterXSS = (data, visited) => {
+  // 字符串直接过滤
+  if (typeof data === "string") return xss(data);
 
-/**
- * 过滤 XSS 攻击代码
- * @param {*} data - 要过滤的数据，可以是字符串、数组或对象
- * @returns {*} 过滤后的数据
- * @description
- * 递归过滤数据中的所有字符串值
- * 使用 xss 库清除危险的 HTML 和 JavaScript 代码
- * 支持字符串、数组和对象的递归处理
- *
- * 安全加固（P2 #22）：
- * 用 WeakSet 跟踪已访问对象，避免循环引用导致栈溢出
- * - 首次遇到对象时加入 visited
- * - 递归处理子属性时传递 visited
- * - 遇到已访问对象直接返回（断开循环）
- *
- * @example
- * const clean = filterXSS({
- *   name: '<script>alert(1)</script>',
- *   items: ['<img src=x onerror=alert(1)>']
- * });
- */
-export function filterXSS(data, visited) {
-  // 字符串：xss 过滤
-  if (typeof data === 'string') {
-    return xss(data);
-  }
+  // 数组遍历递归
+  if (Array.isArray(data)) return data.map(item => filterXSS(item, visited));
 
-  // 数组：递归处理每个元素
-  if (Array.isArray(data)) {
-    // 数组本身不加入 visited（数组循环引用极少见，且会破坏数组的正常处理）
-    // 只跟踪对象的循环引用
-    return data.map(item => filterXSS(item, visited));
-  }
-
-  // 对象：递归处理每个属性
-  if (data && typeof data === 'object') {
-    // 循环引用检测
-    if (!visited) visited = new WeakSet();
-    if (visited.has(data)) {
-      // 已访问过，返回空对象断开循环（保留类型一致性）
-      return {};
-    }
-    visited.add(data);
+  // 普通对象处理，循环引用截断
+  if (data && typeof data === "object") {
+    const vis = visited ?? new WeakSet();
+    if (vis.has(data)) return {};
+    vis.add(data);
 
-    const result = {};
-    for (const key in data) {
-      if (Object.prototype.hasOwnProperty.call(data, key)) {
-        result[key] = filterXSS(data[key], visited);
-      }
+    const target = {};
+    for (const key of Object.keys(data)) {
+      target[key] = filterXSS(data[key], vis);
     }
-    return result;
+    return target;
   }
 
-  // 其他类型（number / boolean / null / undefined / function）：原样返回
+  // number / boolean / null / undefined 直接原值返回
   return data;
-}
+};