mm_os 3.2.4 → 3.2.6

package/middleware/rate_limit/index.js

@@ -0,0 +1,103 @@
+/**
+ * API速率限制中间件
+ * 用于防止DoS攻击，限制客户端在一定时间内的请求频率
+ * @param {Object} server 服务实例
+ * @param {Object} config 配置参数
+ */
+module.exports = function(server, config) {
+    // 初始化速率限制配置
+    const cg = {
+        // 默认配置
+        windowMs: 15 * 60 * 1000, // 时间窗口，默认15分钟
+        maxRequests: 100,         // 每个时间窗口内的最大请求数
+        message: '请求过于频繁，请稍后再试', // 超过限制时的提示信息
+        statusCode: 429,          // 超过限制时的HTTP状态码
+        // 合并用户配置
+        ...(config && config.rateLimit ? config.rateLimit : {})
+    };
+    
+    // 生成基于IP的唯一标识符
+    function getClientKey(ctx) {
+        // 优先使用X-Forwarded-For头部（如果有代理的话）
+        const forwardedFor = ctx.headers['x-forwarded-for'];
+        if (forwardedFor) {
+            // 通常格式为：X-Forwarded-For: client, proxy1, proxy2
+            return forwardedFor.split(',')[0].trim();
+        }
+        // 直接使用IP地址
+        return ctx.ip;
+    }
+    
+    // 使用Redis存储请求计数
+    async function incrementRequestWithRedis(clientKey) {
+        try {
+            // 检查Redis是否可用
+            if ($.cache && typeof $.cache.addInt === 'function') {
+                const key = `rate_limit:${clientKey}`;
+                
+                // 使用addInt方法增加计数（mm_redis包提供的方法）
+                const count = await $.cache.addInt(key, 1);
+                
+                // 设置过期时间
+                await $.cache.ttl(key, Math.ceil(cg.windowMs / 1000));
+                
+                return count || 0;
+            }
+        } catch (error) {
+            $.log.error('Redis速率限制失败:', error);
+        }
+        
+        // Redis不可用时返回null，将使用内存存储
+        return null;
+    }
+
+    // 中间件主逻辑
+    server.use(async (ctx, next) => {
+        try {
+            // 跳过静态文件和favicon请求
+            if (ctx.path === '/favicon.ico' || ctx.path.startsWith('/static/')) {
+                await next();
+                return;
+            }
+            
+            // 获取客户端唯一标识符
+            const clientKey = getClientKey(ctx);
+            
+            let requestCount = await incrementRequestWithRedis(clientKey);
+            
+            // 设置响应头部，告知客户端当前的限制状态
+            ctx.set('X-RateLimit-Limit', cg.maxRequests);
+            ctx.set('X-RateLimit-Remaining', Math.max(0, cg.maxRequests - requestCount));
+            
+            // 检查是否超过限制
+            if (requestCount > cg.maxRequests) {
+                $.log.warn(`API速率限制触发: ${clientKey} 请求 ${ctx.path} 次数过多`);
+                
+                ctx.status = cg.statusCode;
+                ctx.body = {
+                    code: cg.statusCode,
+                    msg: cg.message
+                };
+                
+                // 记录超过限制的请求
+                if ($.log && $.log.warn) {
+                    $.log.warn(`速率限制触发: IP=${clientKey}, Path=${ctx.path}, Method=${ctx.method}`);
+                }
+                
+                return;
+            }
+            
+            // 继续处理请求
+            await next();
+        } catch (error) {
+            $.log.error('速率限制中间件错误:', error);
+            // 确保请求可以继续处理
+            await next();
+        }
+    });
+    
+    // 记录中间件初始化信息
+    $.log.info(`速率限制中间件已加载: ${cg.maxRequests}请求/${cg.windowMs/1000}秒`);
+    
+    return server;
+};

package/middleware/rate_limit/middleware.json

@@ -0,0 +1,10 @@
+{
+  "name": "rate_limit",
+  "title": "API速率限制",
+  "description": "限制客户端在一定时间内的请求频率，防止DoS攻击",
+  "version": "1.0",
+  "type": "web",
+  "process_type": "common_before",
+  "sort": 50,
+  "script": "index.js"
+}

package/middleware/waf/index.js

@@ -51,12 +51,25 @@ function getClientIP(req) {
 module.exports = function(server, config) {
 	/* WAF（web防火墙） */
 	server.use(async (ctx, next) => {
-		var url = ctx.url;
-		var danger = waf_check(url);
-		if (danger) {
-			var ip = getClientIP(ctx.req);
-			$.log.warn(`检测到来自IP ${ip} 的攻击`, "规则:", danger.toString());
-		} else {
+		try {
+			var url = ctx.url;
+			var danger = waf_check(url);
+			if (danger) {
+				var ip = getClientIP(ctx.req);
+				$.log.warn(`检测到来自IP ${ip} 的攻击`, "规则:", danger.toString());
+				// 阻止攻击请求，返回403禁止访问
+				ctx.status = 403;
+				ctx.body = {
+					code: 403,
+					msg: '访问被WAF阻止，请求包含潜在的攻击特征',
+					rule: danger.toString()
+				};
+			} else {
+				await next();
+			}
+		} catch (error) {
+			$.log.error('WAF中间件错误:', error);
+			// 出错时默认允许请求继续处理
 			await next();
 		}
 	});

package/middleware/waf_ip/index.js

@@ -1,8 +1,7 @@
-const os = require('os');
 const {
 	exec
 } = require('child_process');
-const platform = os.platform();
+const platform = require('os').platform();
 
 /**
  * 获取客户端IP
@@ -60,55 +59,108 @@ module.exports = function(server, config) {
 	if (limit && duration) {
 		/* WAF（web防火墙） */
 		server.use(async (ctx, next) => {
-			var pass = true;
-			// 获取IP
-			var ip = getClientIP(ctx.req);
-			var num = 1;
-			var now = new Date();
-			var date = now.toStr('yyyy-MM-dd');
-			var time;
-			var str = await $.cache.get("ip_" + ip);
-			var json;
-			if (str) {
-				if (typeof(str) === "string") {
-					json = JSON.parse(str);
-				} else {
-					json = str;
-				}
-				if (json.date !== date) {
-					num = 1;
-				} else {
-					// 判断时间间隔是否在范围外
-					if (json.time.toTime().interval(now) > duration) {
-						num = 1;
-					} else {
-						// 如果是在周期内，访问次数+1，并判断是否超出上限
-						num = json.num + 1;
-						if (num > limit) {
-							// 超出上限禁止访问，并加入黑名单
-							pass = false;
-							if (block) {
-								setting_blacklist(ip);
+			try {
+				var pass = true;
+				// 获取IP
+				var ip = getClientIP(ctx.req);
+				var num = 1;
+				var now = new Date();
+				var date = now.toStr('yyyy-MM-dd');
+				var time;
+				var json;
+				try {
+					var str = await $.cache.get("ip_" + ip);
+					if (str) {
+						if (typeof(str) === "string") {
+							try {
+								json = JSON.parse(str);
+							} catch (jsonError) {
+								$.log.error('WAF IP中间件JSON解析错误:', jsonError);
+								json = null;
+							}
+						} else {
+							json = str;
+						}
+						if (json) {
+							try {
+								if (json.date !== date) {
+									num = 1;
+								} else {
+									// 判断时间间隔是否在范围外
+									// 安全地处理json.time，无论它是字符串还是对象
+									if (typeof json.time === 'string') {
+										// 如果json.time是字符串，尝试解析它
+										const savedTime = new Date(json.time);
+										if (!isNaN(savedTime.getTime()) && (now - savedTime) > duration) {
+											num = 1;
+										} else {
+											// 如果是在周期内，访问次数+1，并判断是否超出上限
+											num = json.num + 1;
+											if (num > limit) {
+												// 超出上限禁止访问，并加入黑名单
+												pass = false;
+												if (block) {
+													setting_blacklist(ip);
+												}
+											}
+										}
+									} else if (json.time && json.time.toTime && typeof json.time.toTime().interval === 'function') {
+										// 原有逻辑，处理对象类型的时间
+										if (json.time.toTime().interval(now) > duration) {
+											num = 1;
+										} else {
+											// 如果是在周期内，访问次数+1，并判断是否超出上限
+											num = json.num + 1;
+											if (num > limit) {
+												// 超出上限禁止访问，并加入黑名单
+												pass = false;
+												if (block) {
+													setting_blacklist(ip);
+												}
+											}
+										}
+									} else {
+										// 默认情况：如果时间格式不正确，重置计数
+										num = 1;
+									}
+								}
+							} catch (timeError) {
+								$.log.error('WAF IP中间件时间处理错误:', timeError);
+								// 出错时重置计数以保证安全
+								num = 1;
 							}
 						}
 					}
+				} catch (cacheError) {
+					$.log.error('WAF IP中间件缓存操作错误:', cacheError);
+					// 缓存出错时，默认允许请求通过
 				}
-			}
-			if (!time) {
-				time = now.toStr('yyyy-MM-dd hh:mm:ss');
-			}
-			if (pass) {
-				await $.cache.set("ip_" + ip, JSON.stringify({
-					date,
-					time,
-					num
-				}), duration);
-				ctx.request.ip = ip;
-				ctx.ip = ip;
+				if (!time) {
+					time = now.toStr('yyyy-MM-dd hh:mm:ss');
+				}
+				if (pass) {
+					try {
+						await $.cache.set("ip_" + ip, JSON.stringify({
+							date,
+							time,
+							num
+						}), duration);
+					} catch (setCacheError) {
+						$.log.error('WAF IP中间件缓存设置错误:', setCacheError);
+						// 缓存设置失败不影响请求处理
+					}
+					ctx.request.ip = ip;
+					ctx.ip = ip;
+					await next();
+				} else {
+					ctx.status = 429;
+					ctx.body = '请求频率过高，请稍后再试。';
+				}
+			} catch (error) {
+				$.log.error('WAF IP中间件错误:', error);
+				// 出错时默认允许请求通过
+				ctx.ip = getClientIP(ctx.req);
 				await next();
-			} else {
-				ctx.status = 429;
-				ctx.body = '请求频率过高，请稍后再试。';
 			}
 		});
 	}

package/middleware/web_after/index.js

@@ -5,14 +5,27 @@
  */
 module.exports = function(server, config) {
 	server.use(async (ctx, next) => {
-		await next();
-		if (ctx.path !== "/favicon.ico") {
-			await $.eventer.run('web_after', ctx, ctx.db);
-			var event = $.event_admin('api');
-			var ret = await event.after(ctx.path, ctx, ctx.db);
-			if (ret) {
-				ctx.body = ret;
+		try {
+			// 先让其他中间件执行
+			await next();
+			
+			// 然后执行after逻辑
+			try {
+				if (ctx.path !== "/favicon.ico") {
+					await $.eventer.run('web_after', ctx, ctx.db);
+					var event = $.event_admin('api');
+					var ret = await event.after(ctx.path, ctx, ctx.db);
+					if (ret) {
+						ctx.body = ret;
+					}
+				}
+			} catch (afterError) {
+				$.log.error('web_after事件执行错误:', afterError);
+				// 即使after事件出错，也不影响响应结果
 			}
+		} catch (error) {
+			$.log.error('web_after中间件错误:', error);
+			// 注意：这里不需要再次调用next()，因为已经在try块中调用过了
 		}
 	});
 

package/middleware/web_base/index.js

@@ -14,10 +14,22 @@ module.exports = function(server, config) {
 	 * 发送文件
 	 */
 	server.use(async (ctx, next) => {
-		ctx.send = async function(src) {
-			await send(ctx, src);
+		try {
+			ctx.send = async function(src) {
+				try {
+					await send(ctx, src);
+				} catch (sendError) {
+					$.log.error('文件发送错误:', sendError);
+					// 可以选择抛出错误让上层处理，或者静默处理
+					throw sendError;
+				}
+			}
+			await next();
+		} catch (error) {
+			$.log.error('web_base中间件(文件发送设置)错误:', error);
+			// 出错时默认允许请求继续处理
+			await next();
 		}
-		await next();
 	});
 	
 	// 设置session 保存时长2小时
@@ -56,9 +68,21 @@ module.exports = function(server, config) {
 	// 解析 application/json、application/x-www-form-urlencoded、text/plain
 	// 接收主体
 	server.use(async (ctx, next) => {
-		if (!ctx.request.body) {
-			await func(ctx, next);
-		} else {
+		try {
+			if (!ctx.request.body) {
+				try {
+					await func(ctx, next);
+				} catch (parseError) {
+					$.log.error('请求体解析错误:', parseError);
+					// 解析错误时，确保请求继续处理
+					await next();
+				}
+			} else {
+				await next();
+			}
+		} catch (error) {
+			$.log.error('web_base中间件(请求体解析)错误:', error);
+			// 出错时默认允许请求继续处理
 			await next();
 		}
 	});

package/middleware/web_check/index.js

@@ -6,16 +6,22 @@
 module.exports = function(server, config) {
 	// 使用路由(主要)
 	server.use(async (ctx, next) => {
-		if (ctx.path !== "/favicon.ico") {
-			await $.eventer.run('web_check', ctx, ctx.db);
-			var event = $.event_admin('api');
-			var ret = await event.check(ctx.path, ctx, ctx.db);
-			// console.log("check阶段", ret);
-			if (ret) {
-				ctx.body = ret;
+		try {
+			if (ctx.path !== "/favicon.ico") {
+				await $.eventer.run('web_check', ctx, ctx.db);
+				var event = $.event_admin('api');
+				var ret = await event.check(ctx.path, ctx, ctx.db);
+				// console.log("check阶段", ret);
+				if (ret) {
+					ctx.body = ret;
+				}
 			}
+			await next();
+		} catch (error) {
+			$.log.error('web_check中间件错误:', error);
+			// 确保请求可以继续处理
+			await next();
 		}
-		await next();
 	});
 
 	return server;

package/middleware/web_main/index.js

@@ -6,16 +6,22 @@
 module.exports = function(server, config) {
 	// 使用路由(主要)
 	server.use(async (ctx, next) => {
-		if (ctx.path !== "/favicon.ico") {
-			await $.eventer.run('web_main', ctx, ctx.db);
-			var event = $.event_admin('api');
-			var ret = await event.main(ctx.path, ctx, ctx.db);
-			// console.log("main阶段", ret);
-			if (ret) {
-				ctx.body = ret;
+		try {
+			if (ctx.path !== "/favicon.ico") {
+				await $.eventer.run('web_main', ctx, ctx.db);
+				var event = $.event_admin('api');
+				var ret = await event.main(ctx.path, ctx, ctx.db);
+				// console.log("main阶段", ret);
+				if (ret) {
+					ctx.body = ret;
+				}
 			}
+			await next();
+		} catch (error) {
+			$.log.error('web_main中间件错误:', error);
+			// 确保请求可以继续处理
+			await next();
 		}
-		await next();
 	});
 
 	return server;

package/middleware/web_proxy/index.js

@@ -13,11 +13,24 @@ module.exports = function(server, config) {
 	if (config && config.proxy) {
 		var options = config.proxy;
 		if (options.targets) {
-			server.use(proxy(options, function(op, ctx, next) {
-				if (ctx.session && ctx.session.user) {
-					ctx.request.header['user_id'] = ctx.session.user.user_id;
+			server.use(async (ctx, next) => {
+				try {
+					// 先设置用户信息头
+					if (ctx.session && ctx.session.user) {
+						ctx.request.header['user_id'] = ctx.session.user.user_id;
+					}
+					// 创建一个代理处理器
+					const proxyHandler = proxy(options, function(op, ctxProxy, nextProxy) {
+						return nextProxy();
+					});
+					// 执行代理
+					await proxyHandler(ctx, next);
+				} catch (error) {
+					$.log.error('web_proxy中间件错误:', error);
+					// 出错时默认允许请求继续处理
+					await next();
 				}
-			}));
+			});
 		}
 	}
 	return server;

package/middleware/web_render/index.js

@@ -63,18 +63,24 @@ function render_body(ret, res, t) {
 module.exports = function(server, config) {
 	// 使用路由(主要)
 	server.use(async (ctx, next) => {
-		if (ctx.path !== "/favicon.ico") {
-			await $.eventer.run('web_render', ctx, ctx.db);
-			var event = $.event_admin('api');
-			var ret = await event.render(ctx.path, ctx, ctx.db);
-			if (!ctx.body && ret) {
-				ctx.body = ret;
-			}
-			if (ctx.body) {
-				ctx.body = render_body(ctx.body, ctx.response, ctx.request.type);
+		try {
+			if (ctx.path !== "/favicon.ico") {
+				await $.eventer.run('web_render', ctx, ctx.db);
+				var event = $.event_admin('api');
+				var ret = await event.render(ctx.path, ctx, ctx.db);
+				if (!ctx.body && ret) {
+					ctx.body = ret;
+				}
+				if (ctx.body) {
+					ctx.body = render_body(ctx.body, ctx.response, ctx.request.type);
+				}
 			}
+			await next();
+		} catch (error) {
+			$.log.error('web_render中间件错误:', error);
+			// 确保请求可以继续处理
+			await next();
 		}
-		await next();
 	});
 
 	return server;

package/middleware/web_socket/index.js

@@ -12,8 +12,21 @@ module.exports = function(server, config) {
 		//使用 websocket 服务
 		$.socket = new $.Socket();
 		$.socket.update();
-		server.ws.use((ctx, next) => {
-			$.socket.run(ctx, next);
+		server.ws.use(async (ctx, next) => {
+			try {
+				// 确保$.socket.run是异步执行的
+				await Promise.resolve($.socket.run(ctx, next));
+			} catch (error) {
+				$.log.error('web_socket中间件错误:', error);
+				// WebSocket连接错误时，尝试关闭连接以避免资源泄漏
+				try {
+					if (ctx.websocket && ctx.websocket.readyState === ctx.websocket.OPEN) {
+						ctx.websocket.close(1011, 'Internal server error');
+					}
+				} catch (closeError) {
+					// 忽略关闭连接时的错误
+				}
+			}
 		});
 	}
 

package/middleware/web_static/index.js

@@ -1,4 +1,9 @@
+/**
+ * 增强的静态资源处理中间件
+ * 提供缓存控制、压缩、预加载等性能优化功能
+ */
 const statics = require('mm_statics');
+const compress = require('koa-compress');
 
 /**
  * 静态资源请求
@@ -6,20 +11,104 @@ const statics = require('mm_statics');
  * @param {Object} config 配置参数
  */
 module.exports = function(server, config) {
+	// 配置默认值
+	const cg = Object.assign({
+		static: true,
+		maxAge: 365 * 24 * 60 * 60, // 默认缓存一年
+		compress: true,
+		compressThreshold: 1024, // 大于1KB的文件才压缩
+		enablePreload: true, // 启用预加载提示
+		staticPaths: [] // 多路径配置
+	}, config);
+	
 	// 处理静态文件
-	if (config.static) {
-		server.use(statics(
-			config.static_path.fullname(), {
-				maxAge: config.max_age || 0,
-				gzip: config.compress || false,
-				brotli: config.compress || false
+	if (cg.static) {
+		// 添加压缩中间件
+		if (cg.compress && typeof compress === 'function') {
+			server.use(compress({
+				filter: function(content_type) {
+					return /text|json|javascript|css|xml/.test(content_type);
+				},
+				threshold: cg.compressThreshold,
+				gzip: { flush: require('zlib').constants.Z_SYNC_FLUSH },
+				brotli: { flush: require('zlib').constants.BROTLI_OPERATION_FLUSH }
 			}));
-		// 使用多路径静态文件处理器
+		}
+		
+		// 主静态路径处理
+		if (config.static_path) {
+			// 为mm_statics添加错误处理包装器
+			const staticHandler = statics(
+				config.static_path.fullname(), {
+					maxAge: cg.maxAge,
+					gzip: cg.compress,
+					brotli: cg.compress
+				});
+			
+			server.use(async (ctx, next) => {
+				// 预加载提示处理
+				if (cg.enablePreload && ctx.path === '/') {
+					ctx.append('Link', '</static/css/main.css>; rel=preload; as=style');
+					ctx.append('Link', '</static/js/main.js>; rel=preload; as=script');
+				}
+								try {
+				await staticHandler(ctx, next);
+			} catch (staticError) {
+				if (staticError.code !== 'ENOENT') { // 忽略文件不存在的错误
+					$.log.error('静态资源服务错误:', staticError);
+				}
+				// 出错时继续处理请求
+				await next();
+			}
+		});
+		}
+		
+		// 多路径静态文件处理
+		if (Array.isArray(cg.staticPaths) && cg.staticPaths.length > 0) {
+			cg.staticPaths.forEach((pathConfig, index) => {
+				try {
+					const staticPathHandler = statics(
+						pathConfig.path.fullname(),
+						Object.assign({
+							maxAge: cg.maxAge,
+							gzip: cg.compress,
+							brotli: cg.compress
+						}, pathConfig.options || {})
+					);
+					
+					server.use(async (ctx, next) => {
+						try {
+							await staticPathHandler(ctx, next);
+						} catch (e) {
+							if (e.code !== 'ENOENT') {
+								$.log.error(`静态资源路径[${pathConfig.path}]服务错误:`, e);
+							}
+							await next();
+						}
+					});
+				} catch (e) {
+					$.log.error(`静态资源多路径配置错误[${index}]:`, e);
+				}
+			});
+		}
+		
+		// 使用多路径静态文件处理器（保留原有功能）
 		if ($.Static) {
 			const Static = $.Static;
 			$.static = new Static();
 			$.static.update();
-			server.use($.static.run);
+			
+			// 为$.static.run添加错误处理包装器
+			server.use(async (ctx, next) => {
+				try {
+					// 确保静态文件处理器是异步执行的
+					await Promise.resolve($.static.run(ctx, next));
+				} catch (staticRunError) {
+					$.log.error('多路径静态资源服务错误:', staticRunError);
+					// 出错时继续处理请求
+					await next();
+				}
+			});
 		}
 	}
 	return server;