chanjs 2.0.4 → 2.0.5

package/helper/safe.js

@@ -0,0 +1,263 @@
+/**
+ * 安全中间件：用于防御常见Web攻击，包括XSS、SQL注入、点击劫持等
+ * 功能：1. 检测URL中的敏感关键词 2. 设置X-Frame-Options头防止点击劫持
+ */
+/**
+ * 扩展后的敏感关键词列表
+ * 包含：敏感文件扩展名、路径遍历、管理路径、SQL注入、XSS、命令注入等常见攻击特征
+ */
+const defaultKeywords = [
+  // 敏感文件扩展名（路径遍历/敏感文件访问）
+  "\\.(php|asp|aspx|jsp|jspx|go|cgi|pl|sh|bat|exe|sql|rar|gz|tar|tgz|7z|json|xml|vscode|bak|well-known|log|conf|ini|env|yml|yaml|pem|key|crt|db|sqlite)",
+  
+  // 路径遍历特征（目录跳转）
+  "\\.\\./", // ../ 上级目录
+  "\\.\\.\\\\", // ..\  Windows系统上级目录
+  "/etc/", // 系统配置目录
+  "/proc/", // 进程信息目录
+  "/dev/", // 设备文件目录
+  "/root/", // 根用户目录
+  "/home/", // 用户主目录
+  "C:\\\\Windows\\\\", // Windows系统目录
+  "C:\\\\Users\\\\", // Windows用户目录
+  
+  // 敏感管理路径
+  "/manager/",
+  "/backend/",
+  "/system/",
+  "/control/",
+  "/dashboard/",
+  "/wp-admin/", // WordPress管理后台
+  "/phpmyadmin/", // MySQL管理工具
+  "/adminer/",
+  "/pma/",
+  
+  // SQL注入相关关键词
+  "union\\s+select",
+  "drop\\s+table",
+  "delete\\s+from",
+  "insert\\s+into",
+  "update\\s+set",
+  "exec\\s+\\(",
+  "xp_cmdshell", // SQL Server命令执行
+  "into\\s+outfile", // MySQL写文件
+  "load_file\\(", // MySQL读文件
+  "where\\s+1=1", // 条件注入
+  "or\\s+1=1",
+  
+  // XSS相关关键词
+  "script",
+  "alert",
+  "iframe",
+  "onerror",
+  "onclick",
+  "onload",
+  "onmouseover",
+  "confirm",
+  "prompt",
+  "eval",
+  // "javascript:", // JS伪协议
+  // "vbscript:", // VBScript伪协议
+  // "<img", // 图片标签注入
+  // "<svg", // SVG注入
+  // "<video",
+  // "<audio",
+  
+  // 命令注入相关
+  "cmd\\.exe",
+  "bash",
+  "sh",
+  "powershell",
+  "cmd",
+  "system\\(",
+  "shell_exec\\(",
+  "exec\\(",
+  "passthru\\(",
+  "`.*`", // 反引号命令执行
+  "\\|", // 管道符
+  "&", // 后台执行符
+  ";", // 命令分隔符
+  
+  // 敏感操作/信息
+  "document\\.cookie",
+  "window\\.location",
+  "fetch",
+  "xhr",
+  "ajax",
+  "data:", // data协议
+  "root", // 管理员用户
+  "backup",
+  "callback",
+  "ftp",
+  "ssh",
+  "telnet",
+
+  "token",
+  "secret",
+  "password",
+  "passwd",
+
+];
+
+export default defaultKeywords;
+
+
+
+/**
+ * 安全中间件：简化配置的Web安全防御工具
+ * 功能：防点击劫持、敏感请求拦截
+ */
+
+// 基础敏感关键词（高风险攻击特征）
+const baseKeywords = [
+  // SQL注入核心特征
+  'union select', 'drop table', 'delete from',
+  'insert into', 'update .+ set', 'exec\\(',
+  // XSS核心特征
+  '<script', 'onerror=', 'onclick=',
+  'eval\\(', 'document\\.cookie'
+];
+
+/**
+ * 安全中间件主函数
+ * @param {Object} options - 配置选项
+ * @param {string[]} [options.keywords=[]] - 自定义敏感关键词（会与基础关键词合并）
+ * @param {number} [options.threshold=1] - 敏感词匹配阈值（默认匹配1个即拦截）
+ * @param {string} [options.framePolicy='SAMEORIGIN'] - X-Frame-Options策略：DENY/SAMEORIGIN/ALLOW-FROM
+ * @param {string} [options.allowFrom] - 当framePolicy为ALLOW-FROM时的允许地址
+ * @param {string} [options.blockMessage='请求被安全策略拦截'] - 拦截提示信息
+ * @param {Function} [options.onBlock] - 拦截时的回调函数
+ * @returns {Function} Express中间件函数
+ */
+export const safe = (options = {}) => {
+  // 合并默认配置
+  const {
+    keywords = [],
+    threshold = 1,
+    framePolicy = 'SAMEORIGIN',
+    allowFrom = '',
+    blockMessage = '请求被安全策略拦截',
+    onBlock = () => {}
+  } = options;
+
+  // 处理关键词：转义特殊字符，合并基础关键词与自定义关键词
+  const escapedKeywords = [
+    ...baseKeywords,
+    ...keywords.map(kw => kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+  ];
+
+  // 生成不区分大小写的全局匹配正则
+  const keywordReg = new RegExp(`(${escapedKeywords.join('|')})`, 'ig');
+
+  return (req, res, next) => {
+    // 1. 设置防点击劫持头
+    let frameHeader = 'SAMEORIGIN';
+    if (framePolicy === 'DENY') {
+      frameHeader = 'DENY';
+    } else if (framePolicy === 'ALLOW-FROM' && allowFrom) {
+      frameHeader = `ALLOW-FROM ${allowFrom}`;
+    }
+    res.setHeader('X-Frame-Options', frameHeader);
+
+    // 2. 添加XSS防御头
+    res.setHeader('X-XSS-Protection', '1; mode=block');
+
+    // 3. 敏感请求检查
+    // 拼接URL和查询参数作为检查文本
+    const checkText = `${req.url} ${JSON.stringify(req.query)}`;
+    // 匹配所有出现的敏感词
+    const matches = checkText.match(keywordReg) || [];
+    
+    // 去重后判断是否达到阈值
+    if ([...new Set(matches)].length >= threshold) {
+      const logInfo = {
+        method: req.method,
+        url: req.url,
+        ip: req.ip,
+        matches: [...new Set(matches)]
+      };
+      console.error('[安全拦截] 疑似恶意请求:', logInfo);
+      onBlock(logInfo); // 触发拦截回调
+      return res.status(403).send(blockMessage);
+    }
+
+    // 检查通过，继续处理
+    next();
+  };
+};
+
+
+
+// utils/safe.js
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const BASE_KEYWORDS = [
+  'union select', 'drop table', 'delete from',
+  'insert into', 'exec(', '<script', 'onerror=',
+  'onclick=', 'eval(', 'document.cookie'
+];
+
+export const safe = (options = {}) => {
+  const {
+    keywords = [],
+    threshold = 1,
+    blockMessage = '请求被安全策略拦截',
+    onBlock = () => {},
+    enableBodyCheck = true,
+    ignorePaths = [/\/static\//, /\/assets\//, /\.(js|css|png|jpg|jpeg|gif|ico)$/i]
+  } = options;
+
+  // 白名单路径检查
+  const isIgnoredPath = (url) => {
+    return ignorePaths.some(pattern => pattern.test(url));
+  };
+
+  // 所有关键词转义
+  const keywordList = [...BASE_KEYWORDS, ...keywords].map(escapeRegExp);
+
+  return (req, res, next) => {
+    // 1. 白名单路径跳过检查
+    if (isIgnoredPath(req.url)) {
+      return next();
+    }
+
+    // 2. 设置安全头
+    res.setHeader('X-Frame-Options', 'DENY');
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('X-XSS-Protection', '1; mode=block');
+    res.setHeader('Referrer-Policy', 'no-referrer-when-downgrade');
+    res.setHeader('Content-Security-Policy', "frame-ancestors 'self'; default-src 'self'");
+
+    // 3. 构造检查文本
+    let checkText = `${req.url} ${JSON.stringify(req.query)}`;
+    if (enableBodyCheck && req.body) {
+      checkText += ` ${JSON.stringify(req.body)}`;
+    }
+    checkText = checkText.toLowerCase();
+
+    // 4. 逐个检查关键词（性能好，可提前退出）
+    const matches = [];
+    for (const kw of keywordList) {
+      if (checkText.includes(kw.toLowerCase())) {
+        matches.push(kw);
+        if (matches.length >= threshold) break;
+      }
+    }
+
+    if (matches.length >= threshold) {
+      const logInfo = {
+        method: req.method,
+        url: req.url,
+        ip: req.ip,
+        userAgent: req.get('User-Agent'),
+        matches: [...new Set(matches)],
+        timestamp: new Date().toISOString()
+      };
+      console.warn('[安全拦截] 疑似恶意请求:', logInfo);
+      onBlock(logInfo);
+      return res.status(403).send(blockMessage);
+    }
+
+    next();
+  };
+};

package/helper/time.js

@@ -0,0 +1,28 @@
+import dayjs from "dayjs";
+import "dayjs/locale/zh-cn.js";
+import relativeTime from "dayjs/plugin/relativeTime.js";
+
+dayjs.extend(relativeTime);
+dayjs.locale("zh-cn");
+
+/**
+ * @description 格式化时间
+ * @param {Array} data 数组
+ * @param {Boolean} time 是否开启具体时间
+ * @param {String} format YYYY-MM-DD HH:mm:ss
+ * @returns 返回处理过的数组
+ */
+export const formatDay = (data, time = true, format = "YYYY-MM-DD") => {
+  data.forEach((item) => {
+    if (item.createdAt) {
+      item.createdAt = time
+        ? dayjs(item.createdAt).format(format)
+        : dayjs(item.createdAt).fromNow().replace(" ", "");
+    }
+  });
+  return data;
+}
+
+export const formatTime = (data, format = "YYYY-MM-DD HH:mm:ss") => {
+  return dayjs(data).format("YYYY-MM-DD HH:mm:ss");
+}

package/helper/tree.js

@@ -0,0 +1,32 @@
+/**
+ * @param {Array} arr - 原始数据数组
+ * @param {number|string} [pid=0] - 根节点父ID
+ * @param {string} [idKey='id'] - ID字段名
+ * @param {string} [pidKey='pid'] - 父ID字段名
+ * @param {string} [childrenKey='children'] - 子节点字段名
+ * @returns {Array} 树形结构数组
+ */
+export function buildTree(arr, pid = 0, idKey = 'id', pidKey = 'pid', childrenKey = 'children') {
+  // 基础参数校验
+  if (!Array.isArray(arr)) return [];
+  
+  const tree = [];
+  
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    // 找到当前层级的节点
+    if (item[pidKey] === pid) {
+      // 递归查找子节点（通过slice创建子数组，避免重复遍历已处理项）
+      const children = buildTree(arr.slice(i + 1), item[idKey], idKey, pidKey, childrenKey);
+      
+      // 有子节点则添加，避免空数组
+      if (children.length) {
+        item[childrenKey] = children;
+      }
+      
+      tree.push(item);
+    }
+  }
+  
+  return tree;
+}

package/index.js

@@ -1,4 +1,4 @@
-import "./common/global.js";
+import "./global/index.js";
 import path from "path";
 import fs from "fs";
 import {
@@ -24,6 +24,12 @@ import {
 } from "./middleware/index.js";
 
 class Chan {
+
+  //版本号
+  #version = "0.0.0";
+
+  
+
   static helper = {
     bindClass,
     getPackage,
@@ -102,7 +108,7 @@ class Chan {
     if (fs.existsSync(configPath)) {
       const dirs = loaderSort(Chan.config.modules);
       for (const item of dirs) {
-        let router = await importRootFile(`app/modules/${item}/router.js`);
+        let router = await importFile(`app/modules/${item}/router.js`);
         router(this.app, this.router, Chan.config);
       }
     }
@@ -111,7 +117,7 @@ class Chan {
   //通用路由，加载错误处理和500路由和爬虫处理
   async loadCommonRouter() {
     try {
-      let router = await importRootFile("app/router.js");
+      let router = await importFile("app/router.js");
       router(this.app, this.router, Chan.config);
     } catch (error) {
       console.log(error);

package/middleware/safe.js

@@ -0,0 +1,144 @@
+/**
+ * 安全中间件：用于防御常见Web攻击，包括XSS、SQL注入、点击劫持等
+ * 功能：1. 检测URL中的敏感关键词 2. 设置X-Frame-Options头防止点击劫持
+ */
+
+// 默认敏感关键词列表
+// 包含：敏感文件扩展名、管理路径、SQL注入语句、XSS相关函数、敏感操作等
+const defaultKeywords = [
+  // 敏感文件扩展名（可能用于路径遍历或敏感文件访问）
+  "\\.(php|asp|aspx|jsp|jspx|cgi|pl|sh|bat|exe|sql|rar|gz|tar|tgz|7z|json|xml|vscode|bak|well-known)",
+  "admin", // 管理后台路径
+  // SQL注入相关关键词
+  "union\\s+select",
+  "drop\\s+table",
+  "delete\\s+from",
+  "insert\\s+into",
+  "update\\s+set",
+  "exec\\s+\\(",
+  // XSS相关关键词
+  "script",
+  "alert",
+  "iframe",
+  "onerror",
+  "confirm",
+  "prompt",
+  "eval",
+  // 敏感操作/信息
+  "document\\.cookie",
+  "window\\.location",
+  "fetch",
+  "xhr",
+  "ajax",
+  "data",
+  "root",
+  "backup",
+  "callback",
+  "ftp"
+];
+
+/**
+ * 关键词转义处理：将正则特殊字符转义，避免干扰正则匹配
+ * @param {string} keyword - 需要转义的关键词
+ * @returns {string} 转义后的关键词
+ */
+const escapeRegExp = (keyword) => {
+  return keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+};
+
+/**
+ * 检查URL中是否包含敏感关键词
+ * @param {string} url - 需要检查的URL
+ * @param {string[]} customKeywords - 自定义关键词列表
+ * @returns {boolean} 包含敏感词返回true，否则返回false
+ */
+const checkKeywords = (url, customKeywords) => {
+  // 合并默认关键词和自定义关键词，并进行转义处理
+  const allKeywords = [
+    ...defaultKeywords.map(escapeRegExp),
+    ...customKeywords.map(escapeRegExp)
+  ];
+  // 创建不区分大小写的正则表达式
+  const keywordReg = new RegExp(allKeywords.join("|"), "i");
+  return keywordReg.test(url);
+};
+
+/**
+ * 设置X-Frame-Options响应头，防止点击劫持攻击
+ * @param {Object} res - Express响应对象
+ * @param {string} frameOption - 可选值：DENY/SAMEORIGIN/ALLOW-FROM
+ * @param {string} [allowFromUrl] - 当frameOption为ALLOW-FROM时的允许地址
+ */
+const setXFrameOptions = (res, frameOption, allowFromUrl) => {
+  const options = {
+    DENY: "DENY", // 禁止任何页面嵌入
+    SAMEORIGIN: "SAMEORIGIN", // 只允许同源页面嵌入
+    "ALLOW-FROM": `ALLOW-FROM ${allowFromUrl || ''}` // 允许指定来源嵌入
+  };
+
+  // 验证参数有效性
+  if (!Object.keys(options).includes(frameOption)) {
+    console.warn(`无效的X-Frame-Options配置: ${frameOption}，已自动使用SAMEORIGIN`);
+    res.set("X-Frame-Options", "SAMEORIGIN");
+    return;
+  }
+
+  // 处理ALLOW-FROM的特殊情况
+  if (frameOption === "ALLOW-FROM" && !allowFromUrl) {
+    console.warn("使用ALLOW-FROM时必须指定allowFromUrl，已自动使用SAMEORIGIN");
+    res.set("X-Frame-Options", "SAMEORIGIN");
+    return;
+  }
+
+  res.set("X-Frame-Options", options[frameOption]);
+};
+
+/**
+ * 安全中间件主函数
+ * @param {Object} options - 配置选项
+ * @param {string[]} [options.keywords=[]] - 自定义敏感关键词列表
+ * @param {string} [options.sendText="未知请求，已阻止..."] - 拦截时返回的文本
+ * @param {string} [options.frameOption="SAMEORIGIN"] - X-Frame-Options配置
+ * @param {string} [options.allowFromUrl] - 当frameOption为ALLOW-FROM时的允许地址
+ * @returns {Function} Express中间件函数
+ * @example 
+        app.use(safe({
+        keywords: ['custom-badword'], // 自定义敏感词
+        frameOption: 'DENY', // 禁止任何页面嵌入
+        sendText: '请求被安全策略拦截'
+        }));
+ */
+export const safe = (options = {}) => {
+  // 合并默认配置和用户配置
+  const params = { 
+    keywords: [],
+    sendText: "未知请求，已阻止...",
+    frameOption: "SAMEORIGIN",
+    allowFromUrl: "",
+    ...options 
+  };
+
+  // 预编译关键词正则（优化性能：只编译一次）
+  const allKeywords = [
+    ...defaultKeywords.map(escapeRegExp),
+    ...params.keywords.map(escapeRegExp)
+  ];
+  const keywordReg = new RegExp(allKeywords.join("|"), "i");
+
+  // 返回中间件函数
+  return (req, res, next) => {
+    // 1. 设置X-Frame-Options头防止点击劫持
+    setXFrameOptions(res, params.frameOption, params.allowFromUrl);
+
+    // 2. 检查URL中是否包含敏感关键词
+    if (keywordReg.test(req.url)) {
+      console.error(`[安全拦截] 疑似恶意请求: ${req.method} ${req.url} 来自IP: ${req.ip}`);
+      return res.status(403).send(params.sendText);
+    }
+    
+    // 检查通过，继续处理请求
+    next();
+  };
+};
+
+

package/middleware/waf.js

@@ -0,0 +1,197 @@
+import url from "url";
+import {getIp} from "../helper/ip.js";
+
+// 原始关键词列表（保持不变）
+const keywords = [
+  ".aspx",
+  ".php",
+  ".pl",
+  ".jsa",
+  ".jsp",
+  ".asp",
+  ".go",
+  ".jhtml",
+  ".shtml",
+  ".cfm",
+  ".cgi",
+  ".svn",
+  ".env",
+  ".keys",
+  ".cache",
+  ".hidden",
+  ".bod",
+  ".ll",
+  ".backup",
+  ".json",
+  ".xml",
+  ".bak",
+  ".aws",
+  ".database",
+  ".cookie",
+  ".location",
+  ".dump",
+  ".ftp",
+  ".idea",
+  ".s3",
+  ".sh",
+  ".old",
+  ".tf",
+  ".sql",
+  ".vscode",
+  ".docker",
+  ".map",
+  "1+1",
+  ".save",
+  ".gz",
+  ".yml",
+  ".tar",
+  ".rar",
+  ".7z",
+  ".zip",
+  ".git",
+  ".log",
+  ".local",
+  "../",
+  "db_",
+  "smtp",
+  "meta",
+  "debug",
+  "secret",
+  "/xampp/",
+  "/metadata/",
+  "/internal/",
+  "/aws/",
+  "/debug/",
+  "/configs/",
+  "/cgi-bin/",
+  "/tmp/",
+  "/staging/",
+  "/mail/",
+  "/docker/",
+  "/.secure/",
+  "/php-cgi/",
+  "/wp-",
+  "/backup/",
+  "password",
+  "redirect",
+  "/phpMyAdmin/",
+  "/setup/",
+  "concat(",
+  "version(",
+  "sleep(",
+  "benchmark(",
+  "0x7e",
+  "extractvalue(",
+  "(select",
+  "a%",
+  "union",
+  "drop",
+  "update",
+  "insert",
+  "delete",
+  "alter",
+  "truncate",
+  "create",
+  "exec",
+];
+
+// 预处理：合并字符串关键词和正则关键词为两个单一正则（核心优化）
+const { combinedStrRegex, combinedRegRegex } = (() => {
+  const regexSpecialChars = /[.*+?^${}()|[\]\\]/g;
+  const strKwParts = []; // 存储无特殊字符的关键词（用于合并正则）
+  const regKwParts = []; // 存储转义后的正则关键词（用于合并正则）
+
+  keywords.forEach((keyword) => {
+    if (regexSpecialChars.test(keyword)) {
+      // 含正则特殊字符：转义后加入正则关键词部分
+      const escaped = keyword.replace(regexSpecialChars, "\\$&");
+      regKwParts.push(escaped);
+    } else {
+      // 无特殊字符：直接加入字符串关键词部分
+      strKwParts.push(keyword);
+    }
+  });
+
+  // 构建合并后的正则（空数组时返回匹配失败的正则，避免报错）
+  const buildCombinedRegex = (parts) => {
+    return parts.length
+      ? new RegExp(`(?:${parts.join("|")})`, "i") // 非捕获组+不区分大小写
+      : new RegExp("^$"); // 匹配空字符串（永远不命中）
+  };
+
+  return {
+    combinedStrRegex: buildCombinedRegex(strKwParts),
+    combinedRegRegex: buildCombinedRegex(regKwParts),
+  };
+})();
+
+const safe = (req, res, next) => {
+    try {
+      // 1. 设置安全头（保持不变）
+      res.setHeader("X-Frame-Options", "SAMEORIGIN");
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("Referrer-Policy", "no-referrer-when-downgrade");
+      res.removeHeader("Server");
+
+      // 2. 构建检查文本：req.path（仅路径）+ query（非空才加）（优化冗余）
+      let checkText = req.path || "";
+      if (req.query && Object.keys(req.query).length > 0) {
+         const queryStr = Object.entries(req.query)
+          .map(([k, v]) => `${k}=${v}`)
+          .join(' ');
+        checkText += ` ${queryStr}`;
+      }
+
+      // 3. 处理请求体（优化序列化逻辑）
+      let bodyText = "";
+      const contentType = req.headers["content-type"] || "";
+      const isMultipart = contentType.includes("multipart/form-data");
+
+      if (!isMultipart && req.body) {
+        try {
+          // 若已是字符串直接用，否则序列化（避免重复序列化）
+          const bodyStr =
+            typeof req.body === "string" ? req.body : JSON.stringify(req.body);
+
+          // 限制大小（保持原逻辑，避免大文本开销）
+          if (bodyStr.length < 10000) {
+            bodyText = ` ${bodyStr}`;
+          }
+        } catch (e) {
+          // 忽略序列化错误
+        }
+      }
+
+      // 合并完整文本（无需 toLowerCase）
+      const fullText = checkText + bodyText;
+
+      // 4. 高效匹配：两次正则 test 替代 N 次循环（核心优化）
+      let foundMatch = false;
+      // 先检查字符串关键词合并正则（更快，因为无复杂正则逻辑）
+      if (combinedStrRegex.test(fullText)) {
+        foundMatch = true;
+      }
+      // 再检查正则关键词合并正则（仅当字符串匹配未命中时）
+      else if (combinedRegRegex.test(fullText)) {
+        foundMatch = true;
+      }
+
+      if (foundMatch) {
+        console.error("[安全拦截] 疑似恶意请求:", {
+          url: req.url,
+          ip: getIp(req),
+          userAgent: req.get("User-Agent") || "",
+        });
+        return res.status(403).send("请求被安全策略拦截");
+      }
+
+      next();
+    } catch (error) {
+      console.error("[安全中间件异常]", error);
+      res.status(500).send("服务器内部错误");
+    }
+  };
+
+export const waf = (app) => {
+  app.use(safe);
+};