chanjs 2.7.1 → 2.7.3

package/middleware/waf.js

@@ -1,32 +1,28 @@
-import { getIp } from "../helper/ip.js";
-import { checkKeywords } from "../helper/checker.js";
-import { filterXSS } from "../helper/xss-filter.js";
-import { createRateLimitMiddleware } from "../helper/rate-limit.js";
-
-function parseCookies(cookieHeader) {
-  if (!cookieHeader) return {};
-  const cookies = {};
-  cookieHeader.split(';').forEach(cookie => {
-    const [name, value] = cookie.trim().split('=');
-    if (name && value) {
-      cookies[name] = decodeURIComponent(value);
-    }
-  });
-  return cookies;
-}
+import crypto from 'crypto';
+import { getIp } from "../utils/ip.js";
+import { checkKeywords } from "../security/checker.js";
+import { filterXSS } from "../security/xss-filter.js";
+import { createRateLimitMiddleware } from "../security/rate-limit.js";
+import { store } from "../storage/store.js";
 
 /**
  * Web应用防火墙（WAF）中间件
- * 提供访问限流、关键词过滤、XSS防护等功能
+ * 改进点：
+ * 1. 封禁状态存服务端（Map+TTL 或 Redis），按 IP+UA 维度
+ *    - 彻底废弃 Cookie/localStorage 标记方案（旧版可被任意绕过）
+ * 2. 命中恶意关键词后封禁一段时间（默认 30 分钟，可配置）
+ * 3. 支持配置阈值：连续命中 N 次后封禁
+ * 4. 安全响应头补充 X-Frame-Options / HSTS 等
+ * 5. 通过 store 适配层：Redis 启用时走 Redis，否则走内存，运行时异常自动降级
  */
 
-const WAF_BLOCKED_KEY = `${process.env.APP_NAME || 'app'}_waf_blocked`;
-const WAF_BLOCKED_COOKIE = 'waf_blocked';
-const WAF_BLOCKED_HEADER = 'x-waf-blocked';
+// 封禁状态 Redis Key 前缀
+const BLOCK_KEY_PREFIX = 'waf:block:';
+// 封禁命中次数 Redis Key 前缀
+const STRIKE_KEY_PREFIX = 'waf:strike:';
 
 /**
  * 路径白名单 - 这些路径不会被 WAF 检查
- * @type {Array<string>}
  */
 const WAF_PATH_WHITELIST = [
   "/.well-known/appspecific/", // Chrome DevTools
@@ -37,61 +33,119 @@ const WAF_PATH_WHITELIST = [
   "/sitemap.xml", // 站点地图
 ];
 
+/**
+ * 可信 IP 白名单 - 这些 IP 跳过限流和封禁
+ * 本机回环 + RFC 1918 三大私有网段，避免开发和内网环境被误限
+ */
+const TRUSTED_IPS = new Set(['127.0.0.1', '::1', '0.0.0.0']);
+
+/**
+ * 检查 IP 是否可信（本机回环或 RFC 1918 内网）
+ * RFC 1918 私有网段：
+ *   10.0.0.0/8        (10.x.x.x)
+ *   172.16.0.0/12     (172.16.x.x ~ 172.31.x.x)
+ *   192.168.0.0/16    (192.168.x.x)
+ */
+function isTrustedIp(ip) {
+  if (!ip) return false;
+  if (TRUSTED_IPS.has(ip)) return true;
+  // 10.x.x.x
+  if (ip.startsWith('10.')) return true;
+  // 192.168.x.x
+  if (ip.startsWith('192.168.')) return true;
+  // 172.16.x.x ~ 172.31.x.x
+  if (ip.startsWith('172.')) {
+    const second = parseInt(ip.split('.')[1], 10);
+    if (second >= 16 && second <= 31) return true;
+  }
+  return false;
+}
+
 /**
  * 检查路径是否在白名单中
- * @param {string} path - 请求路径
- * @returns {boolean} 是否在白名单中
  */
 function isWhitelistedPath(path) {
-  return WAF_PATH_WHITELIST.some(whitelistPath => 
+  return WAF_PATH_WHITELIST.some(whitelistPath =>
     path.startsWith(whitelistPath) || path === whitelistPath
   );
 }
 
+/**
+ * 生成 IP+UA 维度的标识（sha256 摘要，避免 UA 中特殊字符影响 Key）
+ * @param {string} ip - 客户端 IP
+ * @param {string} ua - User-Agent
+ * @returns {string} 32 位十六进制摘要
+ */
+function buildFingerprint(ip, ua) {
+  return crypto
+    .createHash('sha256')
+    .update(`${ip}|${ua || ''}`)
+    .digest('hex')
+    .slice(0, 32);
+}
+
 /**
  * 创建 WAF 中间件
  * @private
  * @param {Object} wafConfig - WAF 配置对象
- * @param {boolean} wafConfig.enabled - 是否启用 WAF
- * @param {Object} wafConfig.rateLimit - 限流配置
- * @returns {Function} Express 中间件函数
  */
 function createWafMiddleware(wafConfig) {
   const rateLimitMiddleware = createRateLimitMiddleware(wafConfig.rateLimit);
 
+  // 封禁配置（默认 30 分钟，命中 3 次恶意关键词后封禁）
+  const blockConfig = wafConfig.block || {};
+  const BLOCK_DURATION = blockConfig.duration || 30 * 60 * 1000; // 30 分钟
+  const STRIKE_THRESHOLD = blockConfig.strikeThreshold || 3;       // 命中 3 次封禁
+  const STRIKE_WINDOW = blockConfig.strikeWindow || 60 * 60 * 1000; // 1 小时内累计
+
   return async (req, res, next) => {
     try {
       if (!wafConfig.enabled) {
-        console.log('[WAF] WAF已禁用，跳过检查');
         return next();
       }
 
       const clientIp = getIp(req);
+
+      // 可信 IP（本机/内网）仅跳过限流和封禁状态检查（硬约束：避免误限内网）
+      // 但仍执行关键词检查和 XSS 过滤，防止 X-Forwarded-For 伪造内网 IP 绕过 WAF（S-09 修复点）
+      const isTrusted = isTrustedIp(clientIp);
+
       const requestPath = req.path || "";
-      //
+      const userAgent = req.headers['user-agent'] || '';
+      const fingerprint = buildFingerprint(clientIp, userAgent);
+
+      // 安全响应头
       res.setHeader("X-Content-Type-Options", "nosniff");
-      res.setHeader("X-XSS-Protection", "1; mode=block");
-      res.setHeader("X-Frame-Options", "SAMEORIGIN");
+      res.setHeader("Content-Security-Policy", "frame-ancestors 'self'");
+      res.setHeader("X-Frame-Options", "DENY");
 
-      if (!isWhitelistedPath(requestPath)) {
-        const isBlockedHeader = req.headers[WAF_BLOCKED_HEADER];
-        const cookies = parseCookies(req.headers.cookie);
-        const isBlockedCookie = cookies[WAF_BLOCKED_COOKIE];
-        
-        if (isBlockedHeader === 'true' || isBlockedCookie === 'true') {
-          console.error(`[WAF 永久封禁] IP:${clientIp} 路径:${requestPath} 原因:标记封禁`);
+      // 可信 IP 跳过封禁状态检查（避免误封内网）；非可信 IP 才查封禁状态
+      if (!isTrusted && !isWhitelistedPath(requestPath)) {
+        const blockKey = `${BLOCK_KEY_PREFIX}${fingerprint}`;
+        const blocked = await store.get(blockKey);
+
+        if (blocked) {
+          const remaining = Math.ceil((blocked.expireAt - Date.now()) / 60000);
+          console.error(`[WAF 封禁拦截] IP:${clientIp} UA:${userAgent.slice(0, 50)} 剩余:${remaining}分钟`);
           return res.status(403).json({
             code: 403,
             success: false,
-            msg: '您的访问已被限制，如需恢复请联系管理员'
+            msg: '您的访问已被限制，请稍后再试',
+            retryAfter: Math.ceil(BLOCK_DURATION / 1000),
           });
         }
       }
 
-      await new Promise((resolve) => {
-        rateLimitMiddleware(req, res, resolve);
-      });
+      // 可信 IP 跳过限流（避免误限内网）；非可信 IP 才执行限流
+      if (!isTrusted) {
+        await new Promise((resolve) => {
+          rateLimitMiddleware(req, res, resolve);
+        });
+        // 如果限流中间件已经响应（429），不再继续
+        if (res.headersSent) return;
+      }
 
+      // 收集待检查文本：路径 + query + body
       let checkText = requestPath;
       if (req.query && Object.keys(req.query).length > 0) {
         const queryStr = Object.entries(req.query)
@@ -106,6 +160,7 @@ function createWafMiddleware(wafConfig) {
 
       if (!isMultipart && req.body) {
         try {
+          // 先判断 body 长度再决定是否序列化，避免不必要的 CPU 消耗
           const bodyStr = typeof req.body === "string" ? req.body : JSON.stringify(req.body);
           if (bodyStr.length < 10000) {
             bodyText = ` ${bodyStr}`;
@@ -117,6 +172,7 @@ function createWafMiddleware(wafConfig) {
 
       const fullText = checkText + bodyText;
 
+      // 关键词检查（仅对非白名单路径）
       if (!isWhitelistedPath(requestPath)) {
         const matched = checkKeywords(fullText);
 
@@ -124,42 +180,42 @@ function createWafMiddleware(wafConfig) {
           const { category, keyword } = matched;
           console.error(`[WAF 拦截] IP:${clientIp} 路径:${requestPath} 关键词:${keyword} 类别:${category}`);
 
-          const htmlResponse = `
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <meta charset="UTF-8">
-              <title>访问受限</title>
-              <script>
-                (function() {
-                  var expires = new Date();
-                  expires.setTime(expires.getTime() + ${365 * 24 * 60 * 60 * 1000});
-                  document.cookie = '${WAF_BLOCKED_COOKIE}=true; path=/; expires=' + expires.toUTCString() + '; SameSite=Lax';
-                  localStorage.setItem('${WAF_BLOCKED_KEY}', 'true');
-                  console.log('[WAF] Cookie已设置:', document.cookie);
-                })();
-              </script>
-            </head>
-            <body>
-              <h1>非法请求</h1>
-              <p>检测到恶意内容，您的访问已被限制。</p>
-              <p>如需恢复请联系管理员。</p>
-            </body>
-            </html>
-          `;
-
-
-          return res.status(403).setHeader('Content-Type', 'text/html').send(htmlResponse);
+          // 记录命中次数，达到阈值则封禁
+          const strikeKey = `${STRIKE_KEY_PREFIX}${fingerprint}`;
+          const strikes = await store.incrAndExpire(strikeKey, STRIKE_WINDOW);
+
+          if (strikes >= STRIKE_THRESHOLD) {
+            // 封禁：写入封禁状态，TTL = BLOCK_DURATION
+            const blockKey = `${BLOCK_KEY_PREFIX}${fingerprint}`;
+            await store.set(blockKey, { ip: clientIp, reason: keyword, expireAt: Date.now() + BLOCK_DURATION }, BLOCK_DURATION);
+            console.error(`[WAF 封禁触发] IP:${clientIp} 命中次数:${strikes} 封禁时长:${BLOCK_DURATION / 60000}分钟`);
+
+            return res.status(403).json({
+              code: 403,
+              success: false,
+              msg: '检测到恶意访问，您的访问已被限制',
+              retryAfter: Math.ceil(BLOCK_DURATION / 1000),
+            });
+          }
+
+          // 未达阈值，仅拦截本次请求
+          return res.status(403).json({
+            code: 403,
+            success: false,
+            msg: '检测到非法内容，请求已被拦截',
+            data: { strikes, threshold: STRIKE_THRESHOLD },
+          });
         }
       }
 
+      // XSS 过滤
       try {
         if (req.query && typeof req.query === 'object') {
           const filteredQuery = filterXSS(req.query);
           Object.keys(req.query).forEach(key => delete req.query[key]);
           Object.assign(req.query, filteredQuery);
         }
-        
+
         if (req.body && typeof req.body === 'object') {
           req.body = filterXSS(req.body);
         }
@@ -170,7 +226,12 @@ function createWafMiddleware(wafConfig) {
       next();
     } catch (error) {
       console.error(`[WAF 异常] IP:${getIp(req)} 错误:${error.message}`, error.stack);
-      next();
+      // 异常时拒绝请求，避免 WAF 故障时被绕过（fail-closed）
+      return res.status(403).json({
+        code: 403,
+        success: false,
+        msg: '安全检查异常，请求被拒绝',
+      });
     }
   };
 }
@@ -181,17 +242,15 @@ function createWafMiddleware(wafConfig) {
  * @param {Object} config - WAF 配置对象
  * @param {boolean} config.enabled - 是否启用 WAF
  * @param {Object} config.rateLimit - 限流配置
- * @description
- * 为 Express 应用配置 WAF 防护中间件
- * 包含访问限流、关键词过滤、XSS防护和安全响应头设置
- * 路径白名单中的请求不会被 WAF 检查
+ * @param {Object} [config.block] - 封禁配置
+ * @param {number} [config.block.duration=1800000] - 封禁时长（毫秒），默认 30 分钟
+ * @param {number} [config.block.strikeThreshold=3] - 命中恶意关键词几次后封禁
+ * @param {number} [config.block.strikeWindow=3600000] - 命中累计窗口（毫秒）
  * @example
  * waf(app, {
  *   enabled: true,
- *   rateLimit: {
- *     windowMs: 60000,
- *     max: 100
- *   }
+ *   rateLimit: { windowMs: 60000, max: 100 },
+ *   block: { duration: 1800000, strikeThreshold: 3, strikeWindow: 3600000 }
  * });
  */
 export const waf = function (app, config) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "chanjs",
-  "version": "2.7.1",
+  "version": "2.7.3",
   "description": "chanjs基于express5 纯js研发的轻量级mvc框架。",
   "main": "index.js",
   "module": "index.js",
@@ -20,20 +20,19 @@
   "license": "ISC",
   "dependencies": {
     "art-template": "^4.13.4",
-    "body-parser": "^2.2.2",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.6",
     "dayjs": "^1.11.20",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "express-art-template": "^1.0.1",
-    "ip2region": "^2.3.0",
     "jsonwebtoken": "^9.0.3",
     "knex": "^3.2.10",
     "marked": "^18.0.3",
     "morgan": "^1.10.1",
     "mysql2": "^3.22.3",
     "serve-favicon": "^2.5.1",
+    "ws": "^8.18.0",
     "xss": "^1.0.15"
   }
 }

package/realtime/index.js

@@ -0,0 +1,7 @@
+/**
+ * 实时通信模块 - SSE + WebSocket（零第三方依赖）
+ * - sse: Server-Sent Events，单向推送
+ * - websocket: 基于 Node.js v22.4.0+ 原生 WebSocket API
+ */
+export { sse, SSEManager } from "./sse.js";
+export { websocket, WebSocketManager } from "./websocket.js";