mm_os 4.3.7 → 5.0.1

package/common/middleware/web_waf/index.js

@@ -1,395 +0,0 @@
-const rateLimit = require('mm_kernel/common/mod/filter/rate_limit/index.js');
-const ipBlock = require('mm_kernel/common/mod/filter/ip_block/index.js');
-
-/**
- * web防火墙
- */
-module.exports = {
-  /**
-   * 初始化
-   * @param {object} adapter 适配器集合
-   */
-  _init(adapter) {
-    // 获取web服务
-    var web = adapter.web;
-
-    // 获取配置
-    let cg = { ...this.config, ...adapter.web.config };
-
-    // 设置WAF中间件
-    let self = this;
-    web.use(async (ctx, next) => {
-      let waf_check_ret = await self._handleWafCheck(ctx, cg);
-      if (waf_check_ret) {
-        await next();
-      }
-    });
-  },
-
-  /**
-   * 处理WAF检查
-   * @private
-   * @param {object} ctx 上下文
-   * @param {object} cg 配置
-   * @returns {boolean} 是否通过检查
-   */
-  async _handleWafCheck(ctx, cg) {
-    // 获取客户端IP
-    var ip = this._getClientIp(ctx.req);
-
-    // 获取请求路径
-    let path = ctx.path;
-
-    // 检查路径是否在白名单中
-    if (this.isPathWhiteListed(path, cg)) {
-      return true;
-    }
-
-    // IP黑白名单与频率限制检查
-    if (!(await this._checkIpAccess(ip, cg))) {
-      this._sendWafResponse(ctx, 403, '访问被WAF阻止，IP访问受限');
-      return false;
-    }
-
-    // 检查基本攻击特征
-    let danger = this.wafCheck(ctx.url);
-    if (danger) {
-      this._sendWafResponse(ctx, 403, '访问被WAF阻止，请求包含潜在的攻击特征', danger.toString());
-      return false;
-    }
-
-    // 检查路径遍历攻击
-    let path_trav_ret = this._checkPathTrav(ctx);
-    if (path_trav_ret) {
-      this._sendWafResponse(ctx, 403, '访问被WAF阻止，检测到路径遍历攻击尝试');
-      return false;
-    }
-    return true;
-  },
-
-  /**
-   * 检查IP访问权限
-   * @private
-   * @param {string} ip IP地址
-   * @param {object} cg 配置对象
-   * @returns {Promise<boolean>} 是否允许访问
-   */
-  async _checkIpAccess(ip, cg) {
-    if (!ip) {
-      return true;
-    }
-    try {
-      if (await this._checkIpBlocked(ip, cg)) {
-        return false;
-      }
-      return await this._checkRateLimit(ip, cg);
-    } catch {
-      return true;
-    }
-  },
-
-  /**
-   * 检查IP是否在黑名单中
-   * @private
-   * @param {string} ip IP地址
-   * @param {object} cg 配置对象
-   * @returns {Promise<boolean>} 是否被拦截
-   */
-  async _checkIpBlocked(ip, cg) {
-    var blacklist = (cg && cg.web && cg.web.ip_blacklist) || [];
-    if (blacklist.length === 0) {
-      return false;
-    }
-    var ctx = { input: { ip: ip }, output: {}, meta: {} };
-    var done = await ipBlock.main(ctx, { blacklist: blacklist });
-    return done.blocked;
-  },
-
-  /**
-   * 检查请求频率是否超限
-   * @private
-   * @param {string} ip IP地址
-   * @param {object} cg 配置对象
-   * @returns {Promise<boolean>} 是否允许访问
-   */
-  async _checkRateLimit(ip, cg) {
-    var max_req = (cg && cg.web && cg.web.max_req_per_min) || 100;
-    var ctx = { input: {}, output: {}, meta: {} };
-    var done = await rateLimit.main(ctx, {
-      key: 'waf:' + ip,
-      max_requests: max_req,
-      window_ms: 60000
-    });
-    return !done.blocked;
-  },
-
-  /**
-   * 获取客户端IP
-   * @private
-   * @param {object} req 请求对象
-   * @returns {string} 客户端IP
-   */
-  _getClientIp(req) {
-    // 标准IP获取逻辑
-    return req.headers['x-forwarded-for'] || req.headers['X-Forwarded-For'] ||
-      req.connection.remoteAddress ||
-      req.socket.remoteAddress ||
-      req.connection.socket.remoteAddress;
-  },
-
-  /**
-   * 检查路径遍历攻击
-   * @private
-   * @param {object} ctx 上下文
-   * @returns {string|boolean} 检测到的攻击类型或false
-   */
-  _checkPathTrav(ctx) {
-    var path = ctx.path;
-
-    // 检查路径本身
-    if (this.checkPathTrav(path)) {
-      return '路径本身包含攻击特征: ' + path;
-    }
-    if (!this.isSafePath(path)) {
-      return '路径不安全: ' + path;
-    }
-
-    // 检查请求参数
-    var query_params = ctx.query;
-    for (var k in query_params) {
-      var val = query_params[k];
-      if (typeof val === 'string' && this.checkPathTrav(val)) {
-        return '查询参数包含攻击特征: ' + k + '=' + val;
-      }
-    }
-
-    // 检查POST请求体
-    if (ctx.method === 'POST' && ctx.request.body) {
-      var body_content = JSON.stringify(ctx.request.body);
-      if (this.checkPathTrav(body_content)) {
-        return '请求体包含攻击特征';
-      }
-    }
-
-    return false;
-  },
-
-  /**
-   * 发送WAF响应
-   * @private
-   * @param {object} ctx 上下文
-   * @param {number} status 状态码
-   * @param {string} msg 消息
-   * @param {string} [rule] 规则
-   */
-  _sendWafResponse(ctx, status, msg, rule) {
-    ctx.status = status;
-    ctx.body = {
-      code: status,
-      msg: msg,
-      rule: rule
-    };
-  },
-
-  /**
-   * 获取SQL注入检测规则
-   * @private
-   * @returns {RegExp[]} SQL注入规则列表
-   */
-  _getSqlRules() {
-    return [
-      /select.+(from|limit)/i,
-      /(?:(union(.*?)select))/i,
-      /sleep\((\s*)(\d*)(\s*)\)/i,
-      /group\s+by.+\(/i,
-      /(?:from\W+information_schema\W)/i,
-      /(?:(?:current_)user|database|schema|connection_id)\s*\(/i,
-      /\s*or\s+.*=.*/i,
-      /order\s+by\s+.*--$/i,
-      /benchmark\((.*)\,(.*)\)/i,
-      /base64_decode\(/i,
-      /(?:(?:current_)user|database|version|schema|connection_id)\s*\(/i,
-      /(?:etc\/\W*passwd)/i,
-      /into(\s+)+(?:dump|out)file\s*/i
-    ];
-  },
-
-  /**
-   * 获取代码注入和XSS检测规则
-   * @private
-   * @returns {RegExp[]} 代码注入和XSS规则列表
-   */
-  _getCodeInjectRules() {
-    return [
-      /xwork.MethodAccessor/i,
-      /(?:define|eval|file_get_contents|include|require|require_once)\(/i,
-      /(?:shell_exec|phpinfo|system|passthru|preg_\w+|execute)\(/i,
-      /(?:echo|print|print_r|var_dump|(fp)open|alert|showmodaldialog)\(/i,
-      /\<(iframe|script|body|img|layer|div|meta|style|base|object|input)/i,
-      /(onmouseover|onmousemove|onerror|onload)\=/i,
-      /javascript:/i
-    ];
-  },
-
-  /**
-   * 获取路径遍历检测规则
-   * @private
-   * @returns {RegExp[]} 路径遍历规则列表
-   */
-  _getPathTravRules() {
-    return [
-      // 增强的路径遍历检测规则
-      /\.\.\//i, // 基础 ../
-      /\.\.\\/i, // Windows格式 ..\
-      /\%2e\%2e\//i, // URL编码 ../
-      /\%2e%2e\//i, // URL编码 ../
-      /\%252e%252e%2f/i, // 双重URL编码 ../
-      /\%252e\%252e\%2f/i, // 双重URL编码 ../
-      /\.\%2e\//i, // 混合编码
-      /\%2e\./i, // 变体形式
-      /\%5c/i, // 反斜杠URL编码
-      /\%255c/i, // 反斜杠双重URL编码
-      // 系统文件路径检测 - 改进以避免误判
-      new RegExp('(?:\\/etc\\/|\\/proc\\/|C:\\\\Windows\\|' +
-        'C:\\\\winnt\\|C:\\\\Program Files\\|\\/sys\\/)', 'i')
-    ];
-  },
-
-  /**
-   * 获取命令注入检测规则
-   * @private
-   * @returns {RegExp[]} 命令注入规则列表
-   */
-  _getCmdInjectRules() {
-    return [
-      // 命令注入检测
-      new RegExp('\\|\\|.*(?:ls|pwd|whoami|ll|ifconfog|' +
-        'ipconfig|&&|chmod|cd|mkdir|rmdir|cp|mv)', 'i'),
-      new RegExp('(?:ls|pwd|whoami|ll|ifconfog|ipconfig|' +
-        '&&|chmod|cd|mkdir|rmdir|cp|mv).*\\|\\|', 'i'),
-      new RegExp('(gopher|doc|php|glob|file|phar|zlib|ftp|' +
-        'ldap|dict|ogg|data)\\:\/', 'i')
-    ];
-  },
-
-  /**
-   * 获取WAF规则列表
-   * @private
-   * @returns {RegExp[]} WAF规则列表
-   */
-  _getWafRules() {
-    return [
-      ...this._getSqlRules(),
-      ...this._getCodeInjectRules(),
-      ...this._getPathTravRules(),
-      ...this._getCmdInjectRules()
-    ];
-  },
-
-  /**
-   * 使用正则表达式，检测字符串是否含有攻击特征，检测到攻击特征返回true，没检测到返回false
-   * @param {string} url 网址
-   * @returns {RegExp|null} 检测到的攻击规则或null
-   */
-  wafCheck(url) {
-    var rules = this._getWafRules();
-    for (var i = 0; i < rules.length; i++) {
-      if (rules[i].test(url)) {
-        return rules[i];
-      }
-    }
-    return null;
-  },
-
-  /**
-   * 检查路径是否包含路径遍历攻击
-   * @param {string} path 路径
-   * @returns {boolean} 是否包含路径遍历
-   */
-  checkPathTrav(path) {
-    // 处理URL编码变体
-    let url_decoded = decodeURIComponent(path);
-    let double_url_decoded = decodeURIComponent(url_decoded);
-
-    // 检查路径是否包含危险模式
-    let danger_patterns = [
-      '../', '../../', '../../../', // Unix/Linux格式
-      '..\\', '..\\\\', '..\\\\\\\\', // Windows格式
-      '/%2e%2e/', '/%2e%2e%2f', // URL编码变体
-      '\\%2e%2e\\', '\\%2e%2e\\\\' // Windows URL编码变体
-    ];
-
-    // 检查系统关键文件路径（绝对路径攻击）
-    let sys_paths = [
-      '/etc/passwd', '/etc/shadow', '/etc/group', '/etc/hosts',
-      '/proc/', '/bin/', '/usr/bin/',
-      'C:\\Windows\\', 'C:\\winnt\\', 'C:\\Program Files\\'
-    ];
-
-    // 检查原始路径、单次解码和双重解码后的路径
-    // 1. 检查相对路径遍历模式
-    let has_trav_pattern = danger_patterns.some(pattern =>
-      path.includes(pattern) ||
-      url_decoded.includes(pattern) ||
-      double_url_decoded.includes(pattern)
-    );
-
-    // 2. 检查绝对路径攻击（包含系统关键文件路径）
-    let has_abs_attack = sys_paths.some(sys_path =>
-      path.toLowerCase().includes(sys_path.toLowerCase()) ||
-      url_decoded.toLowerCase().includes(sys_path.toLowerCase()) ||
-      double_url_decoded.toLowerCase().includes(sys_path.toLowerCase())
-    );
-
-    return has_trav_pattern || has_abs_attack; // 移除starts_with_slash检查
-  },
-
-  /**
-   * 检查请求路径是否规范化，防止路径遍历攻击
-   * @param {string} path 请求路径
-   * @returns {boolean} 是否为安全路径
-   */
-  isSafePath(path) {
-    // 特殊处理根路径，直接返回安全
-    if (path === '/') {
-      return true;
-    }
-
-    // 获取规范化的路径
-    let norm_path = path.split('/')
-      .filter(segment => segment !== '')
-      .reduce((acc, segment) => {
-        // 防止路径回溯
-        if (segment === '..') {
-          acc.pop();
-        } else if (segment !== '.') {
-          acc.push(segment);
-        }
-        return acc;
-      }, [])
-      .join('/');
-
-    // 重新构建规范化的完整路径
-    let safe_path = '/' + norm_path;
-
-    // 检查规范化后的路径长度是否小于原始路径（表示存在路径回溯）
-    return safe_path.length >= path.length - 2; // 允许末尾的 '/' 差异
-  },
-
-  /**
-   * 检查路径是否在白名单中
-   * @param {string} path 请求路径
-   * @param {object} config WAF配置
-   * @returns {boolean} 是否在白名单中
-   */
-  isPathWhiteListed(path, config) {
-    // 获取配置中的路径白名单
-    let path_white_list = (config && config.web && config.web.path_whitelist)
-      || (config && config.path_whitelist)
-      || ['/static', '/favicon.ico', '/api', '/public', '/assets'];
-
-    // 检查路径是否以白名单中的任何路径开头
-    return Array.isArray(path_white_list) &&
-      path_white_list.some(white_path => path.startsWith(white_path));
-  }
-};

package/common/middleware/web_waf/middleware.json

@@ -1,13 +0,0 @@
-{
-	"name": "web_waf",
-	"title": "web防火墙",
-	"description": "用于防止sql注入、脚本注入等",
-	"version": "1.0",
-	"main": "index.js",
-	"type": "web",
-	"state": 1,
-	"sort": 50,
-	"log": true,
-	"ip_whitelist": ["127.0.0.1", "::1", "localhost"],
-	"path_whitelist": ["/favicon.ico", "/static", "/api", "/public", "/assets"]
-}

package/core/app/config.tpl.json

@@ -1,67 +0,0 @@
-{
-	// 名称
-	"name": "${name}",
-	// 标题
-	"title": "${title || '示例标题'}",
-	// 描述
-	"description": "${description || '示例描述'}",
-	// 版本号
-	"version": "${version || '1.0.0'}",
-	// 作者
-	"author": "${author || 'qww'}",
-	// 主文件
-	"main": "${main || 'index.js'}",
-	// 作用域，决定加载到什么区域（server/client/both）
-	"scope": "${scope || 'server'}",
-	// 状态 0：禁用 1：启用
-	"state": 1,
-	// 排序，越小越靠前
-	"sort": 100,
-	// 依赖的npm module
-	"dependencies": [],
-	// 检索的目录
-	"dir": "${dir || ''}",
-	// 是否为游戏应用
-	"is_game": false,
-	// // 游戏配置，非游戏模块不需要配置
-	// "game": {
-	// 	// 游戏类型
-	// 	"type": "card_game"
-	// },
-	// 自定义数据库 - 1 开启 0 关闭
-	"diy_sql": 0,
-	// 自定义缓存 - 1 开启 0 关闭
-	"diy_cache": 0,
-	// sql 配置 - 可以没有，没有则使用默认数据库
-	"sql": {
-		// 数据库方式
-		"way": "mysql",
-		"mysql": {
-			// 数据库主机
-			"host": "127.0.0.1",
-			// 数据库端口
-			"port": 3306,
-			// 数据库用户名
-			"username": "root",
-			// 数据库密码
-			"password": "your_db_password_here",
-			// 数据库名称
-			"database": "mm"
-		}
-	},
-	// 缓存配置 - 可以没有，没有则使用默认缓存
-	"cache": {
-		// 缓存方式方式
-		"way": "redis",
-		"redis": {
-			// 缓存主机
-			"host": "127.0.0.1",
-			// 缓存端口
-			"port": 6379,
-			// 缓存密码
-			"password": "your_redis_password_here",
-			// 缓存数据库
-			"database": 0
-		}
-	}
-}