chanjs 2.0.5 → 2.0.7

package/helper/safe.js

@@ -1,263 +0,0 @@
-/**
- * 安全中间件：用于防御常见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/tree.js

@@ -1,32 +0,0 @@
-/**
- * @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/middleware/safe.js

@@ -1,144 +0,0 @@
-/**
- * 安全中间件：用于防御常见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/utils/bind.js

@@ -1,21 +0,0 @@
-
-/**
- * @description 实例化一个类，并将该类的所有方法绑定到一个新的对象上。
- * @param {Function} className - 需要实例化的类。
- *@returns {Object} 包含绑定方法的对象。
- */
- export const bindClass = function(className) {
-  let obj = {};
-  const cls = new className();
-  Object.getOwnPropertyNames(cls.constructor.prototype).forEach(
-    (methodName) => {
-      if (
-        methodName !== "constructor" &&
-        typeof cls[methodName] === "function"
-      ) {
-        obj[methodName] = cls[methodName].bind(cls);
-      }
-    }
-  );
-  return obj;
-}

package/utils/dataparse.js

@@ -1,24 +0,0 @@
-/**
- * 将数组转换为键值对对象
- * @param {Array} arr - 包含键值对的数组
- * @param {string} keyField - 作为键的字段名
- * @param {string} valueField - 作为值的字段名
- * @returns {Object} 转换后的对象
- */
-export const arrToObj = (arr, keyField = 'config_key', valueField = 'config_value') => {
-    // 输入验证
-    if (!Array.isArray(arr)) {
-      throw new Error('arrToObj 期望接收数组作为第一个参数');
-    }
-    
-    return arr.reduce((result, item) => {
-      if (item && typeof item === 'object') {
-        const key = item[keyField];
-        const value = item[valueField];
-        if (key !== undefined && value !== undefined) {
-          result[key] = value;
-        }
-      }
-      return result;
-    }, {});
-  };

package/utils/db.js

@@ -1,75 +0,0 @@
-import knex from "knex";
-export const db = function ({
-  client = "mysql2",
-  host = "127.0.0.1",
-  user = "root",
-  password = "123456",
-  database = "test",
-  port = 3306,
-  debug = true,
-  charset = "utf8mb4",
-  min = 0,
-  max = 2,
-}) {
-  let config = {
-    client,
-    connection: {
-      host,
-      port,
-      user,
-      password,
-      database,
-      charset,
-    },
-    debug,
-    pool: {
-      //默认为{min: 2, max: 10},连接池配置
-      min,
-      max,
-    },
-    log: {
-      warn(message) {
-        console.error("[knex warn]", message);
-      },
-      error(message) {
-        console.error("[knex error]", message);
-      },
-      debug(message) {
-        console.log("[knex debug]", message);
-      },
-      deprecate(message) {
-        console.warn("[knex deprecate]", message);
-      },
-      trace(message) {
-        console.log("[knex trace]", message);
-      },
-      log(message) {
-        console.log("[knex log]", message);
-      },
-      info(message) {
-        console.log("[knex info]", message);
-      },
-    },
-  };
-  return knex(config);
-};
-
-const errCode = {
-  ECONNREFUSED: "数据库连接被拒绝，请检查数据库服务是否正常运行。",
-  ER_ACCESS_DENIED_ERROR: "无权限访问，账号或密码错误。",
-  ER_ROW_IS_REFERENCED_2: "无法删除或更新记录，存在关联数据。",
-  ER_BAD_FIELD_ERROR: "SQL语句中包含无效字段，请检查查询条件或列名。",
-  ER_DUP_ENTRY: "插入失败：数据重复，违反唯一性约束。",
-  ER_NO_SUCH_TABLE: "操作失败：目标表不存在。",
-  ETIMEOUT: "数据库操作超时，请稍后再试。",
-};
-const getDefaultErrorMessage = (error) => {
-  if (error.message.includes("syntax") || error.message.includes("SQL")) {
-    return "数据库语法错误，请检查您的查询语句。";
-  } else if (error.message.includes("Connection closed")) {
-    return "数据库连接已关闭，请重试。";
-  } else if (error.message.includes("permission")) {
-    return "数据库权限不足，请检查配置。";
-  }
-  return "数据库发生未知错误，请稍后重试。";
-};

package/utils/index.js

@@ -1,12 +0,0 @@
-import {bindClass} from './bind.js'
-import {db} from './db.js'
-import {loaderSort,getPackage,loadConfig,loadController} from './loader.js'
-
-export {
-    bindClass,
-    db,
-    loaderSort,
-    getPackage,
-    loadConfig,
-    loadController
-}

package/utils/loader.js

@@ -1,65 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { bindClass } from "./bind.js";
-
-/**
- *
- * @param {*} module 模块目录
- * @returns Array
- * @description 将web模块放到最后加载
- */
-export const loaderSort = (modules = []) => {
-  const index = modules.indexOf("web");
-  if (index !== -1) {
-    const web = modules.splice(index, 1);
-    modules.push(web[0]);
-  }
-  return modules;
-};
-
-export const getPackage = async function () {
-  let pkg = await importFile("package.json");
-  return pkg;
-};
-
-export const loadConfig = async function () {
-  let config = await importFile("config/index.js");
-  console.log("config", config);
-  return config;
-};
-
-/**
- * 加载指定模块名下的所有控制器文件
- * @param {string} moduleName - 模块名称
- * @returns {Promise<Object>} - 控制器对象
- */
-export const loadController = async function (moduleName) {
-  const controller = {};
-
-  const dir = path.join(MODULES_PATH, moduleName, "controller");
-
-  if (!fs.existsSync(dir)) {
-    console.warn(`模块路径不存在，跳过加载控制器: ${dir}`);
-    return controller;
-  }
-
-  const files = fs.readdirSync(dir).filter((file) => file.endsWith(".js"));
-
-  for (const file of files) {
-    const filePath = path.join(dir, file);
-    const name = file.replace(/\.js$/i, ""); // 安全处理 .js 后缀
-
-    try {
-      const module = await importFile(filePath);
-      let obj = module.default || module;
-
-      controller[name] = obj;
-    } catch (e) {
-      console.error(`加载控制器失败: ${filePath}`, e);
-      // 可选：抛出错误或继续加载其他文件
-      // throw e;
-    }
-  }
-
-  return controller;
-};

package/utils/response.js

@@ -1,20 +0,0 @@
-export function parseJsonFields(obj) {
-    const result = {};
-    for (const key in obj) {
-      if (!obj.hasOwnProperty(key)) continue;
-      const value = obj[key];
-      // 如果是字符串，并且看起来像 JSON（以 { 或 [ 开头）
-      if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
-        try {
-          result[key] = JSON.parse(value);
-        } catch (e) {
-          console.warn(`JSON parse failed for field: ${key}`, e);
-          result[key] = value; // 保留原始值
-        }
-      } else {
-        result[key] = value;
-      }
-    }
-  
-    return result;
-  }