mm_os 3.3.1 → 4.0.1

package/middleware/waf_ddos/index.js

@@ -1,520 +0,0 @@
-const mm_expand = require('mm_expand');
-
-/**
- * 综合流量控制与DDOS攻击防护中间件
- * 合并了原rate_limit和ddos_protection的功能，提供全面的流量防护机制
- */
-class Middleware {
-	/**
-	 * 构造函数
-	 */
-	constructor() {
-		// 内存存储，用于记录请求计数和IP信息
-		this.ipRequestCount = new Map();
-		this.blockedIps = new Map();
-		this.connectionCount = new Map();
-
-		this.default = {
-			// 启用综合流量保护
-			enable: true,
-			// 存储方式: 'memory', 'redis'
-			storage: 'memory',
-			// 基于IP的速率限制
-			ip_rate_limit: {
-				// 时间窗口(毫秒)
-				window_ms: 60000,
-				// 每个IP在时间窗口内的最大请求数
-				max_requests: 500,
-				// 是否启用
-				enable: true
-			},
-			// 基于路径的速率限制
-			path_rate_limit: {
-				// 时间窗口(毫秒)
-				window_ms: 60000,
-				// 每个IP对每个路径在时间窗口内的最大请求数
-				max_requests: 250,
-				// 是否启用
-				enable: true
-			},
-			// 连接限制
-			connection_limit: {
-				// 单个IP的最大并发连接数
-				max_connections: 50,
-				// 是否启用
-				enable: true
-			},
-			// 阻止规则
-			blocking: {
-				// 触发阻止的阈值倍数
-				threshold: 2,
-				// 阻止时间(毫秒)
-				block_time: 300000, // 5分钟
-				// 是否自动解除阻止
-				auto_unblock: true
-			},
-			// 白名单IP
-			whitelist: [],
-			// 忽略的路径（白名单路径）
-			ignore_paths: ['/api/health', '/favicon.ico', '/static/'],
-			// 是否记录攻击尝试
-			log: true,
-			// 是否阻止恶意请求
-			block: true,
-			// 响应状态码
-			status_code: 429,
-			// 响应消息
-			response_message: '请求过于频繁，请稍后再试',
-			// 是否设置X-RateLimit响应头
-			set_rate_limit_headers: true
-		};
-	}
-
-	/**
-	 * 初始化中间件
-	 * @param {Object} config 配置项
-	 */
-	init(config) {
-		config = Object.assign({}, this.default, config);
-		this.config = config;
-
-		// 启动清理过期数据的定时器（仅在内存存储模式下需要）
-		if (config.storage === 'memory') {
-			this.startCleanupTimer();
-		}
-
-		return function() {
-			// 返回中间件的run方法作为实际的处理函数
-			return function(ctx, next) {
-				return middleware.run(ctx, next);
-			};
-		};
-	}
-
-	/**
-	 * 获取客户端真实IP
-	 * 在代理环境中，优先从代理头获取真实IP
-	 * @param {Object} ctx Koa上下文
-	 * @returns {String} 客户端真实IP
-	 */
-	getClientIp(ctx) {
-		const headers = ctx.headers;
-		// 优先检查常用代理头获取真实IP
-		const xForwardedFor = headers['x-forwarded-for'];
-		if (xForwardedFor) {
-			// X-Forwarded-For 格式通常为: client, proxy1, proxy2
-			const ips = xForwardedFor.split(',').map(ip => ip.trim());
-			for (let i = 0; i < ips.length; i++) {
-				const ip = ips[i];
-				if (ip && ip !== 'unknown' && ip !== '127.0.0.1' && ip !== '::1') {
-					return ip;
-				}
-			}
-		}
-
-		// 检查其他常见的代理头
-		return headers['x-real-ip'] ||
-			headers['x-client-ip'] ||
-			headers['cf-connecting-ip'] || // CloudFlare
-			headers['fastly-client-ip'] || // Fastly
-			headers['true-client-ip'] || // Akamai and Cloudflare
-			ctx.ip; // 默认回退到ctx.ip
-	}
-
-	/**
-	 * 使用Redis存储请求计数（从rate_limit中间件合并的功能）
-	 * @param {String} clientKey 客户端标识符（通常是IP）
-	 * @param {String} prefix 键前缀
-	 * @param {Number} windowMs 时间窗口（秒）
-	 * @returns {Promise<Number>} 请求计数
-	 */
-	async incrementRequestWithRedis(clientKey, prefix, windowMs) {
-		try {
-			// 检查Redis是否可用
-			if ($.cache && typeof $.cache.addInt === 'function') {
-				const key = `${prefix}:${clientKey}`;
-
-				// 使用addInt方法增加计数（mm_redis包提供的方法）
-				const count = await $.cache.addInt(key, 1);
-
-				// 设置过期时间
-				await $.cache.ttl(key, Math.ceil(windowMs / 1000));
-
-				return count || 0;
-			}
-		} catch (error) {
-			if (this.config.log && $.log && $.log.error) {
-				$.log.error('Redis速率限制失败:', error);
-			}
-		}
-
-		// Redis不可用时返回null，将使用内存存储
-		return null;
-	}
-
-	/**
-	 * 执行中间件
-	 * @param {Object} ctx Koa上下文
-	 * @param {Function} next 下一个中间件
-	 */
-	async run(ctx, next) {
-		const config = this.config;
-		// 使用改进的IP获取方法
-		const ip = this.getClientIp(ctx);
-		const path = ctx.path;
-
-		if (!config.enable) {
-			return await next();
-		}
-
-		// 检查是否在白名单中
-		if (this.isWhitelisted(ip)) {
-			return await next();
-		}
-
-		// 检查是否应该忽略该路径
-		if (this.shouldIgnorePath(path)) {
-			return await next();
-		}
-
-		// 检查IP是否被阻止
-		if (this.isBlocked(ip)) {
-			if (config.log && $.log && $.log.warn) {
-				$.log.warn('Blocked IP Attempted Access:', {
-					ip: ip,
-					path: path,
-					method: ctx.method
-				});
-			}
-
-			ctx.status = config.status_code;
-			ctx.body = {
-				code: config.status_code,
-				msg: config.response_message
-			};
-			return;
-		}
-
-		// 检查连接限制
-		if (config.connection_limit.enable && !this.checkConnectionLimit(ip)) {
-			this.blockIp(ip, 'Exceeded connection limit');
-			ctx.status = config.status_code;
-			ctx.body = {
-				code: config.status_code,
-				msg: config.response_message
-			};
-			return;
-		}
-
-		// 检查IP速率限制
-		let requestCount = null;
-
-		if (config.ip_rate_limit.enable) {
-			if (config.storage === 'redis') {
-				// 使用Redis进行速率限制
-				requestCount = await this.incrementRequestWithRedis(
-					ip,
-					'rate_limit',
-					config.ip_rate_limit.window_ms
-				);
-
-				if (requestCount !== null) {
-					// Redis成功执行了计数
-					if (requestCount > config.ip_rate_limit.max_requests) {
-						this.blockIp(ip, 'Exceeded IP rate limit');
-
-						// 设置响应头
-						if (config.set_rate_limit_headers) {
-							ctx.set('X-RateLimit-Limit', config.ip_rate_limit.max_requests);
-							ctx.set('X-RateLimit-Remaining', 0);
-						}
-
-						ctx.status = config.status_code;
-						ctx.body = {
-							code: config.status_code,
-							msg: config.response_message
-						};
-						return;
-					}
-
-					// 设置响应头
-					if (config.set_rate_limit_headers) {
-						ctx.set('X-RateLimit-Limit', config.ip_rate_limit.max_requests);
-						ctx.set('X-RateLimit-Remaining', Math.max(0, config.ip_rate_limit.max_requests -
-							requestCount));
-					}
-				} else {
-					// Redis不可用，使用内存存储方式
-					if (!this.checkIpRateLimit(ip)) {
-						this.blockIp(ip, 'Exceeded IP rate limit');
-						ctx.status = config.status_code;
-						ctx.body = {
-							code: config.status_code,
-							msg: config.response_message
-						};
-						return;
-					}
-				}
-			} else {
-				// 使用内存存储方式
-				if (!this.checkIpRateLimit(ip)) {
-					this.blockIp(ip, 'Exceeded IP rate limit');
-					ctx.status = config.status_code;
-					ctx.body = {
-						code: config.status_code,
-						msg: config.response_message
-					};
-					return;
-				}
-			}
-		}
-
-		// 检查路径速率限制（仅内存存储支持）
-		if (config.path_rate_limit.enable && config.storage === 'memory') {
-			if (!this.checkPathRateLimit(ip, path)) {
-				this.blockIp(ip, `Exceeded path rate limit for ${path}`);
-				ctx.status = config.status_code;
-				ctx.body = {
-					code: config.status_code,
-					msg: config.response_message
-				};
-				return;
-			}
-		}
-
-		// 增加连接计数
-		this.incrementConnection(ip);
-
-		try {
-			await next();
-		} finally {
-			// 减少连接计数
-			this.decrementConnection(ip);
-		}
-	}
-
-	/**
-	 * 检查IP是否在白名单中
-	 * @param {String} ip IP地址
-	 * @returns {Boolean} 是否在白名单中
-	 */
-	isWhitelisted(ip) {
-		return this.config.whitelist.includes(ip);
-	}
-
-	/**
-	 * 检查是否应该忽略该路径
-	 * @param {String} path 路径
-	 * @returns {Boolean} 是否忽略
-	 */
-	shouldIgnorePath(path) {
-		return this.config.ignore_paths.some(p => path === p || path.startsWith(p));
-	}
-
-	/**
-	 * 检查IP是否被阻止
-	 * @param {String} ip IP地址
-	 * @returns {Boolean} 是否被阻止
-	 */
-	isBlocked(ip) {
-		const blocked = this.blockedIps.get(ip);
-		if (!blocked) return false;
-
-		// 如果启用了自动解除阻止
-		if (this.config.blocking.auto_unblock) {
-			if (Date.now() > blocked.unblock_time) {
-				this.blockedIps.delete(ip);
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * 阻止IP
-	 * @param {String} ip IP地址
-	 * @param {String} reason 阻止原因
-	 */
-	blockIp(ip, reason) {
-		if (!this.config.block) return;
-
-		const blockTime = this.config.blocking.block_time;
-		const unblockTime = Date.now() + blockTime;
-
-		this.blockedIps.set(ip, {
-			reason: reason,
-			block_time: Date.now(),
-			unblock_time: unblockTime
-		});
-
-		if (this.config.log && $.log && $.log.warn) {
-			$.log.warn('IP Blocked:', {
-				ip: ip,
-				reason: reason,
-				block_time: new Date().toISOString(),
-				unblock_time: new Date(unblockTime).toISOString()
-			});
-		}
-	}
-
-	/**
-	 * 检查连接限制
-	 * @param {String} ip IP地址
-	 * @returns {Boolean} 是否通过检查
-	 */
-	checkConnectionLimit(ip) {
-		const count = this.connectionCount.get(ip) || 0;
-		return count < this.config.connection_limit.max_connections;
-	}
-
-	/**
-	 * 增加连接计数
-	 * @param {String} ip IP地址
-	 */
-	incrementConnection(ip) {
-		const count = this.connectionCount.get(ip) || 0;
-		this.connectionCount.set(ip, count + 1);
-	}
-
-	/**
-	 * 减少连接计数
-	 * @param {String} ip IP地址
-	 */
-	decrementConnection(ip) {
-		const count = this.connectionCount.get(ip);
-		if (count && count > 0) {
-			this.connectionCount.set(ip, count - 1);
-		} else {
-			this.connectionCount.delete(ip);
-		}
-	}
-
-	/**
-	 * 检查IP速率限制（内存存储方式）
-	 * @param {String} ip IP地址
-	 * @returns {Boolean} 是否通过检查
-	 */
-	checkIpRateLimit(ip) {
-		const now = Date.now();
-		const windowMs = this.config.ip_rate_limit.window_ms;
-		const maxRequests = this.config.ip_rate_limit.max_requests;
-
-		let requests = this.ipRequestCount.get(ip) || [];
-
-		// 清理过期的请求记录
-		requests = requests.filter(timestamp => now - timestamp < windowMs);
-
-		// 检查是否超过限制
-		if (requests.length >= maxRequests) {
-			return false;
-		}
-
-		// 添加当前请求时间戳
-		requests.push(now);
-		this.ipRequestCount.set(ip, requests);
-
-		return true;
-	}
-
-	/**
-	 * 检查路径速率限制（内存存储方式）
-	 * @param {String} ip IP地址
-	 * @param {String} path 路径
-	 * @returns {Boolean} 是否通过检查
-	 */
-	checkPathRateLimit(ip, path) {
-		const key = `${ip}:${path}`;
-		const now = Date.now();
-		const windowMs = this.config.path_rate_limit.window_ms;
-		const maxRequests = this.config.path_rate_limit.max_requests;
-
-		let requests = this.ipRequestCount.get(key) || [];
-
-		// 清理过期的请求记录
-		requests = requests.filter(timestamp => now - timestamp < windowMs);
-
-		// 检查是否超过限制
-		if (requests.length >= maxRequests) {
-			return false;
-		}
-
-		// 添加当前请求时间戳
-		requests.push(now);
-		this.ipRequestCount.set(key, requests);
-
-		return true;
-	}
-
-	/**
-	 * 启动清理过期数据的定时器
-	 */
-	startCleanupTimer() {
-		// 每30秒清理一次过期数据
-		setInterval(() => {
-			this.cleanupExpiredData();
-		}, 30000);
-	}
-
-	/**
-	 * 清理过期数据
-	 */
-	cleanupExpiredData() {
-		const now = Date.now();
-
-		// 清理过期的IP请求记录
-		for (const [key, requests] of this.ipRequestCount.entries()) {
-			const cleanedRequests = requests.filter(timestamp =>
-				now - timestamp < Math.max(this.config.ip_rate_limit.window_ms, this.config.path_rate_limit
-					.window_ms)
-			);
-
-			if (cleanedRequests.length > 0) {
-				this.ipRequestCount.set(key, cleanedRequests);
-			} else {
-				this.ipRequestCount.delete(key);
-			}
-		}
-
-		// 自动解除过期的阻止
-		if (this.config.blocking.auto_unblock) {
-			for (const [ip, blockInfo] of this.blockedIps.entries()) {
-				if (now > blockInfo.unblock_time) {
-					this.blockedIps.delete(ip);
-					if (this.config.log && $.log && $.log.info) {
-						$.log.info('IP Unblocked Automatically:', {
-							ip: ip,
-							reason: blockInfo.reason
-						});
-					}
-				}
-			}
-		}
-	}
-}
-
-// 创建中间件实例
-const middleware = new Middleware();
-
-// 导出符合系统期望的函数
-exports = module.exports = function(server, config) {
-	// 初始化中间件
-	const handlerFactory = middleware.init(config);
-	const middlewareHandler = handlerFactory();
-
-	// 直接使用server.use注册中间件
-	server.use(middlewareHandler);
-
-	// 记录中间件初始化信息
-	if ($.log && $.log.info) {
-		const cg = middleware.config;
-		$.log.info(
-			`综合流量控制中间件已加载: 存储方式=${cg.storage}, IP限制=${cg.ip_rate_limit.max_requests}/${cg.ip_rate_limit.window_ms/1000}秒, 连接限制=${cg.connection_limit.max_connections}`
-			);
-	}
-
-	return server;
-};
-
-// 保留原始实例，以便其他方式调用
-exports.middleware = middleware;

package/middleware/waf_ddos/middleware.json

@@ -1,38 +0,0 @@
-{
-  "name": "waf_ddos",
-  "title": "综合流量控制与DDOS攻击防护中间件",
-  "type": "web_before",
-  "state": 1,
-  "sort": 12,
-  "desc": "提供DDOS攻击防护和速率限制，包括IP限流、路径限流、连接控制和IP封禁功能",
-  "config": {
-    "enable": true,
-    "storage": "memory",
-    "ip_rate_limit": {
-      "window_ms": 60000,
-      "max_requests": 500,
-      "enable": true
-    },
-    "path_rate_limit": {
-      "window_ms": 60000,
-      "max_requests": 250,
-      "enable": true
-    },
-    "connection_limit": {
-      "max_connections": 50,
-      "enable": true
-    },
-    "blocking": {
-      "threshold": 2,
-      "block_time": 300000,
-      "auto_unblock": true
-    },
-    "whitelist": [],
-    "ignore_paths": ["/api/health", "/favicon.ico", "/static/"],
-    "log": true,
-    "block": true,
-    "status_code": 429,
-    "response_message": "请求过于频繁，请稍后再试",
-    "set_rate_limit_headers": true
-  }
-}