mm_os 3.2.6 → 3.2.8

package/core/base/mqtt/index.js

@@ -7,12 +7,9 @@ const mosca = require('mosca');
 class MQTT {
 	/**
 	 * 构造函数
-	 * @param {Object} config 配置参数
+	 * @param {Object} config 配置参数	
 	 */
 	constructor(config) {
-		/**
-		 * 配置参数
-		 */
 		this.config = Object.assign({
 			"state": true,
 			// mqtt访问端口号
@@ -23,6 +20,36 @@ class MQTT {
 			"http_port": 8083,
 			// 缓存方式
 			"cache": "mongodb", // "mongodb",
+			// 消息保留时长(秒)
+			"message_retention": 86400,
+			// 消息频率限制配置
+			"rate_limit": {
+				// 时间窗口（毫秒）
+				"time_window": 60000, // 默认1分钟
+				// 时间窗口内允许的最大消息数
+				"max_messages": 100,  // 人脸识别门禁优化：1分钟内最多20条消息（门禁通常每次识别仅发送1-3条消息）
+				// 拉黑时长（毫秒）
+				"block_duration": 3600000 // 人脸识别门禁优化：拉黑30分钟（更合理的临时限制时长）
+			},
+			// 重连检测配置
+			"reconnect_detection": {
+				// 时间窗口（毫秒）
+				"time_window": 60000, // 默认1分钟
+				// 最大允许重连次数
+				"max_reconnect_attempts": 5,
+				// 同一客户端ID不同IP的禁止时间（毫秒）
+				"ip_ban_duration": 3600000, // 默认1小时
+				// 客户端ID禁止重连时间（毫秒）
+				"client_id_ban_duration": 7200000, // 默认2小时
+				// 频繁重连时间阈值（毫秒）
+				"frequent_reconnect_threshold": 30000 // 默认30秒
+			},
+			// 受限主题列表，用于限制某些敏感主题只能由特定客户端订阅
+			restrictedTopics: [],
+			// 允许订阅受限主题的客户端列表
+			allowedClients: [],
+			// 敏感主题列表，用于限制某些敏感主题只能由管理员发布
+			sensitiveTopics: [],
 			redis: {
 				host: "localhost",
 				port: 6379,
@@ -44,24 +71,76 @@ class MQTT {
 		this.server = null;
 
 		this.list = [];
+
+		/**
+		 * 客户端消息计数器
+		 * 格式: { clientId: { count: 消息数, lastReset: 上次重置时间戳 } }
+		 */
+		this.messageCounters = {};
+
+		/**
+		 * 拉黑的客户端列表
+		 * 格式: { clientId: 解除拉黑时间戳 }
+		 */
+		this.blockedClients = {};
+
+		/**
+		 * 客户端连接历史记录
+		 * 格式: { clientId: { ip: 客户端IP, connectCount: 连接次数, lastConnectTime: 上次连接时间, disconnectTime: 上次断开时间, reconnectAttempts: 重连尝试次数 } }
+		 */
+		this.clientHistory = {};
+
+		/**
+		 * 被禁止的IP列表
+		 * 格式: { ip: 解除禁止时间戳 }
+		 */
+		this.bannedIps = {};
+
+		/**
+		 * 黑名单存储类型
+		 * 可选值: 'memory', 'redis', 'mongodb', 'mysql'
+		 */
+		this.blacklistStorageType = this.config.blacklistStorageType || 'memory';
 	}
 }
 
 /**
- * 客户端连接成功
+ * 异步客户端连接成功
  * @param {Object} client 客户端信息
+ * @returns {Promise<Boolean>} true表示连接成功，false表示连接被拒绝
  */
-MQTT.prototype.connected = async function(client) {
-	//监听连接
-	console.info('client connected', client.id);
-	return true;
+MQTT.prototype.connected = async function (client) {
+	try {
+		// 检测是否有异常重连行为 - 现在是异步函数
+		const hasReconnectAbuse = await this.detectReconnectAbuse(client);
+		if (hasReconnectAbuse) {
+			$.log.warn(`拒绝客户端 ${client.id} 连接：检测到异常重连行为`);
+			// 断开客户端连接
+			if (client && client.close) {
+				try {
+					client.close();
+				} catch (error) {
+					$.log.error(`断开异常重连客户端 ${client.id} 连接时出错:`, error);
+				}
+			}
+			return false;
+		}
+
+		// 正常连接
+		$.log.info('client connected', client.id);
+		return true;
+	} catch (error) {
+		$.log.error(`处理客户端 ${client.id} 连接时出错:`, error);
+		// 出错时默认拒绝连接
+		return false;
+	}
 }
 
 /**
  * 初始化
  * @param {Object} config
  */
-MQTT.prototype.init = function(config) {
+MQTT.prototype.init = function (config) {
 	if (config) {
 		this.config = Object.assign(this.config, config);
 	}
@@ -105,10 +184,10 @@ MQTT.prototype.init = function(config) {
 		conf.persistence = Object.assign({
 			factory: mosca.persistence.Redis,
 			ttl: {
-				// TTL for subscriptions is 23 hour 
-				subscriptions: 23 * 60 * 60 * 1000,
-				// TTL for packets is 23 hour 
-				packets: 23 * 60 * 60 * 1000,
+				// TTL for subscriptions
+				subscriptions: cg.message_retention * 1000,
+				// TTL for packets
+				packets: cg.message_retention * 1000,
 			}
 		}, conf.backend);
 	} else if (cg.cache === 'mongodb' || cg.cache === 'mongo') {
@@ -129,10 +208,10 @@ MQTT.prototype.init = function(config) {
 		conf.persistence = Object.assign({
 			factory: mosca.persistence.Mongo,
 			ttl: {
-				// TTL for subscriptions is 23 hour 
-				subscriptions: 23 * 60 * 60 * 1000,
-				// TTL for packets is 23 hour 
-				packets: 23 * 60 * 60 * 1000,
+				// TTL for subscriptions
+				subscriptions: cg.message_retention * 1000,
+				// TTL for packets
+				packets: cg.message_retention * 1000,
 			}
 		}, conf.backend);
 	}
@@ -144,7 +223,7 @@ MQTT.prototype.init = function(config) {
  * 引用
  * @param {Function} 函数
  */
-MQTT.prototype.use = function(func) {
+MQTT.prototype.use = function (func) {
 	// this.server.use(func);
 };
 
@@ -152,7 +231,7 @@ MQTT.prototype.use = function(func) {
  * 运行主程序
  * @param {String} state 状态
  */
-MQTT.prototype.main = function(state) {
+MQTT.prototype.main = function (state) {
 	var cg = this.config;
 	var sr = this.server;
 
@@ -162,16 +241,34 @@ MQTT.prototype.main = function(state) {
 	 * 对服务器端口进行配置，在此端口进行监听
 	 * @param {Object} client 客户端信息
 	 */
-	sr.on('clientConnected', async function(client) {
+	sr.on('clientConnected', async function (client) {
 		return await _this.connected(client);
 	});
-	
+
 	/**
 	 * 监听MQTT主题消息
 	 * @param {Object} packet 订阅消息
 	 * @param {Object} client 客户端信息
 	 */
-	sr.on('published', function(packet, client) {
+	sr.on('published', async function (packet, client) {
+		// 检查客户端是否高频请求
+		if (client) {
+			try {
+				const isHighFrequency = await _this.checkHighFrequency(client);
+				if (isHighFrequency) {
+					// 高频请求，拉黑并断开连接
+					await _this.blockClient(client);
+					return;
+				}
+			} catch (error) {
+				$.log.error(`检查客户端高频请求时出错:`, error);
+				// 发生错误时，默认拒绝请求
+				if (client && client.close) {
+					client.close();
+				}
+				return;
+			}
+		}
 		_this.published(packet, client);
 	});
 
@@ -180,7 +277,7 @@ MQTT.prototype.main = function(state) {
 	 * @param {String} topic 订阅主题
 	 * @param {Object} client 客户端信息
 	 */
-	sr.on('subscribed', function(topic, client) {
+	sr.on('subscribed', function (topic, client) {
 		_this.subscribed(topic, client);
 	});
 
@@ -189,34 +286,54 @@ MQTT.prototype.main = function(state) {
 	 */
 	sr.authenticate = (client, username, password, callback) => {
 		$.log.info("收到身份验证", username, password);
-		this.auth(client, username, password, callback);
+		// 因为auth现在是异步函数，需要使用async/await处理
+		(async () => {
+			try {
+				// 调用异步的auth函数，但仍然使用callback返回结果
+				// auth函数内部已经处理了callback调用
+				await this.auth(client, username, password, callback);
+			} catch (error) {
+				$.log.error(`身份验证过程发生异常:`, error);
+				callback(null, false);
+			}
+		})();
+		// 返回true表示继续处理
 		return true;
 	};
-	
+
 	/**
 	 * 验证发布，决定客户端可以发布哪些主题
 	 */
 	sr.authorizePublish = (client, topic, payload, callback) => {
-		this.authPublish(client, topic, payload, callback);
+		const isAllowed = this.authPublish(client, topic, payload);
+		callback(null, isAllowed);
 		return true;
 	};
-	
-	
+
+
 	/**
 	 * 验证订阅，决定客户端可以订阅哪些主题
 	 */
 	sr.authorizeSubscribe = (client, topic, callback) => {
-		this.authSubscribe(client, topic, callback);
+		const isAllowed = this.authSubscribe(client, topic);
+		callback(null, isAllowed);
 		return true;
 	};
-	
-	
+
+
 	/**
 	 * 当服务开启时
 	 */
-	sr.on('ready', function() {
+	sr.on('ready', function () {
 		// 当服务开启时
-		console.info(`MQTT访问 mqtt://127.0.0.1:${cg.socket_port} || ws://127.0.0.1:${cg.http_port}`);
+		$.log.info(`MQTT访问 mqtt://127.0.0.1:${cg.socket_port} || ws://127.0.0.1:${cg.http_port}`);
+	});
+
+	/**
+	 * 监听客户端断开连接
+	 */
+	sr.on('clientDisconnected', async function (client) {
+		_this.clientDisconnected(client);
 	});
 }
 
@@ -225,95 +342,176 @@ MQTT.prototype.main = function(state) {
  * @param {String} topic 订阅主题
  * @param {Object} client 客户端信息
  */
-MQTT.prototype.subscribed = function(topic, client) {
+MQTT.prototype.subscribed = function (topic, client) {
 	// console.log("订阅", topic, client.id);
 };
 
+/**
+ * 客户端断开连接时的处理
+ * @param {Object} client 客户端对象
+ */
+MQTT.prototype.clientDisconnected = function (client) {
+	const clientId = client.id;
+	const now = Date.now();
+
+	$.log.info(`MQTT客户端 ${clientId} 断开连接`);
+
+	// 更新客户端断开连接时间
+	if (this.clientHistory[clientId]) {
+		this.clientHistory[clientId].disconnectTime = now;
+	}
+};
+
 /**
  * 收到推送消息时
  * @param {Object} packet 订阅的消息
  * @param {Object} client 客户端信息
  */
-MQTT.prototype.published = function(packet, client) {
+MQTT.prototype.published = function (packet, client) {
 	// console.log("发布", packet.topic, packet.payload.toString());
 };
 
 /**
- * 身份验证 - 使用MySQL数据库验证
+ * 身份验证 - 主要入口函数
  * @param {Object} client 客户端
  * @param {String} username 用户名
  * @param {String} password 密码
  * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
  */
-MQTT.prototype.auth = function(client, username, password, callback) {
-	// 密码可能是Buffer类型，需要转换为字符串
-	const passwordStr = password ? password.toString() : '';
-	
-	// 检查必要参数
-	if (!username || !passwordStr) {
-		console.warn(`MQTT客户端 ${client.id} 身份验证失败：用户名或密码为空`);
-		callback(null, false);
-		return;
-	}
-	
-	// 检查是否有可用的MySQL连接
-	if (!$.sql || typeof $.sql.query !== 'function') {
-		console.error(`MQTT客户端 ${client.id} 身份验证错误：MySQL连接不可用`);
-		callback(null, false);
-		return;
-	}
-	
-	// 使用参数化查询以防止SQL注入
-	const sql = `SELECT password FROM mqtt_users WHERE username = ? LIMIT 1`;
-	const params = [username];
-	
-	// 执行查询验证用户
-	$.sql.query(sql, params, (err, results) => {
-		if (err) {
-			console.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
+MQTT.prototype.auth = async function (client, username, password, callback) {
+	try {
+		// 检查客户端状态（拉黑、异常重连等）- 现在是异步操作
+		const clientStatusResult = await this.checkClientStatus(client);
+		if (clientStatusResult === false) {
 			callback(null, false);
 			return;
 		}
-		
-		// 检查用户是否存在
-		if (!results || results.length === 0) {
-			console.warn(`MQTT客户端 ${client.id} 身份验证失败：用户不存在，用户名: ${username}`);
+
+		// 密码可能是Buffer类型，需要转换为字符串
+		const passwordStr = password ? password.toString() : '';
+
+		// 验证凭证格式
+		const credentialsResult = this.validateCredentials(client, username, passwordStr);
+		if (credentialsResult === false) {
 			callback(null, false);
 			return;
 		}
-		
-		// 获取数据库中的密码
-		const dbPassword = results[0].password;
-		
-		// 验证密码
-		// 注意：在实际应用中，应该使用bcrypt等密码哈希算法进行验证，而不是明文比较
-		// 如果数据库中存储的是哈希密码，需要使用相应的哈希算法进行验证
-		try {
-			// 尝试使用bcrypt验证（如果已安装bcrypt模块）
-			const bcrypt = require('bcrypt');
-			const isMatch = bcrypt.compareSync(passwordStr, dbPassword);
-			
-			if (isMatch) {
-				console.info(`MQTT客户端 ${client.id} 身份验证成功，用户: ${username}`);
-			} else {
-				console.warn(`MQTT客户端 ${client.id} 身份验证失败：密码不匹配，用户名: ${username}`);
-			}
-			
-			callback(null, isMatch);
-		} catch (err) {
-			// 如果bcrypt不可用，回退到简单的密码比较（不推荐在生产环境中使用）
-			console.warn('bcrypt模块不可用，使用简单密码比较');
-			const isMatch = dbPassword === passwordStr;
-			
-			if (isMatch) {
-				console.info(`MQTT客户端 ${client.id} 身份验证成功，用户: ${username}`);
-			} else {
-				console.warn(`MQTT客户端 ${client.id} 身份验证失败：密码不匹配，用户名: ${username}`);
-			}
-			
-			callback(null, isMatch);
+
+		// 查询用户密码并验证（异步操作，需要callback）
+		this.checkAccount(client, username, passwordStr, callback);
+	} catch (error) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证过程中出错:`, error);
+		callback(null, false);
+	}
+};
+
+/**
+ * 异步检查客户端状态（拉黑、异常重连等）
+ * @param {Object} client 客户端
+ * @returns {Promise<Boolean>} true表示客户端状态正常，false表示客户端状态异常
+ */
+MQTT.prototype.checkClientStatus = async function (client) {
+	try {
+		// 检查客户端是否被拉黑（使用新的异步函数）
+		const isBlocked = await this.isClientBlocked(client.id);
+		if (isBlocked) {
+			$.log.warn(`MQTT客户端 ${client.id} 处于拉黑状态，拒绝身份验证`);
+			return false;
 		}
-	});
+
+		// 检测是否有异常重连行为
+		// 注意：detectReconnectAbuse内部也有黑名单相关操作，后续可以考虑重构为使用异步函数
+		if (this.detectReconnectAbuse(client)) {
+			$.log.warn(`拒绝客户端 ${client.id} 身份验证：检测到异常重连行为`);
+			return false;
+		}
+
+		return true;
+	} catch (error) {
+		$.log.error(`检查客户端 ${client.id} 状态时出错:`, error);
+		// 出错时默认视为客户端状态异常
+		return false;
+	}
+};
+
+/**
+ * 验证凭证格式
+ * @param {Object} client 客户端
+ * @param {String} username 用户名
+ * @param {String} passwordStr 密码字符串
+ * @returns {Boolean} true表示凭证格式有效，false表示凭证格式无效
+ */
+MQTT.prototype.validateCredentials = function (client, username, passwordStr) {
+	// 检查必要参数
+	if (!username || !passwordStr) {
+		$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：用户名或密码为空`);
+		return false;
+	}
+
+	// 检查是否有可用的MySQL连接
+	if (!$.mysql_admin) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证错误：MySQL连接不可用`);
+		return false;
+	}
+
+	return true;
+};
+
+/**
+ * 查询用户密码并验证
+ * @param {Object} client 客户端
+ * @param {String} username 用户名
+ * @param {String} passwordStr 密码字符串
+ * @param {Function} callback 回调函数
+ */
+MQTT.prototype.checkAccount = function (client, username, passwordStr, callback) {
+	var sql = $.mysql_admin('sys');
+	try {
+		var db = sql.db();
+		db.table = this.config.table_name || 'face_device';
+		// 先尝试通过客户端ID和用户名精确匹配
+		db.getObj({
+			clientid: client.id,
+			username: username
+		}).then((obj) => {
+			if (!obj) {
+				$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：用户不存在，用户名: ${username}`);
+				callback(null, false);
+				return;
+			}
+			// 验证密码
+			this.verifyPassword(client, username, passwordStr, obj.password, callback);
+		}).catch((err) => {
+			$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
+			callback(null, false);
+			return;
+		});
+	} catch (error) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, error);
+		callback(null, false);
+		return;
+	}
+};
+
+/**
+	 * 验证密码
+	 * @param {Object} client 客户端
+	 * @param {String} username 用户名
+	 * @param {String} passwordStr 密码字符串
+	 * @param {String} dbPassword 数据库中的密码
+	 * @param {Function} callback 回调函数
+	 */
+MQTT.prototype.verifyPassword = function (client, username, passwordStr, dbPassword, callback) {
+	// 使用简单的密码比较（当前实现，可根据需要扩展为bcrypt验证）
+	const isMatch = dbPassword === passwordStr;
+
+	if (isMatch) {
+		$.log.info(`MQTT客户端 ${client.id} 身份验证成功，用户: ${username}`);
+	} else {
+		$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：密码不匹配，用户名: ${username}`);
+	}
+
+	callback(null, isMatch);
 };
 
 /**
@@ -321,69 +519,64 @@ MQTT.prototype.auth = function(client, username, password, callback) {
  * @param {Object} client 客户端
  * @param {String} topic 主题
  * @param {Object} payload 参数
- * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
+ * @returns {Boolean} true表示验证通过，false表示验证失败
  */
-MQTT.prototype.authPublish = function(client, topic, payload, callback) {
+MQTT.prototype.authPublish = function (client, topic, payload) {
 	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
 	// 在实际应用中，应该从数据库或配置中获取客户端的发布权限
 	let isAllowed = true;
-	
+
 	// 例如：限制某些敏感主题只能由管理员发布
-	const sensitiveTopics = ['system/settings', 'admin/commands'];
-	const isSensitiveTopic = sensitiveTopics.some(sensitiveTopic => 
-		 topic === sensitiveTopic || topic.startsWith(sensitiveTopic + '/')
+	const isSensitiveTopic = (this.config.sensitiveTopics || []).some(sensitiveTopic =>
+		topic === sensitiveTopic || topic.startsWith(sensitiveTopic + '/')
 	);
-	
+
 	// 简单示例：检查客户端ID是否表示管理员客户端
-	const isAdminClient = client.id === 'admin_client' || client.id.startsWith('admin_');
-	
+	const isAdminClient = client.id === 'admin' || client.id.startsWith('server_');
+
 	if (isSensitiveTopic && !isAdminClient) {
 		isAllowed = false;
-		console.warn(`MQTT客户端 ${client.id} 被拒绝发布到敏感主题: ${topic}`);
+		$.log.warn(`MQTT客户端 ${client.id} 被拒绝发布到敏感主题: ${topic}`);
 	}
-	
-	// 回调第二个参数为true表示验证通过, 为false表示验证失败
-	callback(null, isAllowed);
+
+	return isAllowed;
 };
 
 /**
  * 验证订阅，决定客户端可以订阅哪些主题
  * @param {Object} client 客户端
  * @param {String} topic 主题
- * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
+ * @returns {Boolean} true表示验证通过，false表示验证失败
  */
-MQTT.prototype.authSubscribe = function(client, topic, callback) {
+MQTT.prototype.authSubscribe = function (client, topic) {
 	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
 	// 在实际应用中，应该从数据库或配置中获取客户端的订阅权限
 	let isAllowed = true;
-	
+
 	// 例如：限制某些敏感主题只能由特定客户端订阅
-	const restrictedTopics = ['private/data', 'user/+/profile'];
-	const isRestrictedTopic = restrictedTopics.some(restrictedTopic => {
+	const isRestrictedTopic = (this.config.restrictedTopics || []).some(restrictedTopic => {
 		// 处理通配符，例如：user/+/profile 匹配 user/123/profile, user/456/profile 等
 		const pattern = restrictedTopic.replace(/\+/g, '[^/]+');
 		const regex = new RegExp(`^${pattern}$`);
 		return regex.test(topic);
 	});
-	
+
 	// 简单示例：允许特定客户端订阅受限主题
-	const allowedClients = ['trusted_client', 'monitoring_service'];
-	const isAllowedClient = allowedClients.includes(client.id);
-	
+	const isAllowedClient = (this.config.allowedClients || []).includes(client.id);
+
 	if (isRestrictedTopic && !isAllowedClient) {
 		isAllowed = false;
-		console.warn(`MQTT客户端 ${client.id} 被拒绝订阅受限主题: ${topic}`);
+		$.log.warn(`MQTT客户端 ${client.id} 被拒绝订阅受限主题: ${topic}`);
 	}
-	
-	// 回调第二个参数为true表示验证通过, 为false表示验证失败
-	callback(null, isAllowed);
+
+	return isAllowed;
 };
 
 /**
  * 运行主程序前
  * @param {String} state 状态
  */
-MQTT.prototype.before = async function(state) {
+MQTT.prototype.before = async function (state) {
 	var list = this.list;
 	for (var i = 0; i < list.length; i++) {
 		var o = list[i];
@@ -398,16 +591,330 @@ MQTT.prototype.before = async function(state) {
  * 运行主程序后
  * @param {String} state 状态
  */
-MQTT.prototype.after = async function(state) {};
+MQTT.prototype.after = async function (state) { };
+
+/**
+ * 检查客户端是否高频请求
+ * @param {Object} client 客户端对象
+ * @returns {Boolean} true表示高频请求，false表示正常请求
+ */
+MQTT.prototype.checkHighFrequency = async function (client) {
+	const clientId = client.id;
+	const now = Date.now();
+	const config = this.config.rate_limit;
+
+	// 检查是否已经被拉黑
+	try {
+		const isBlocked = await this.isClientBlocked(clientId);
+		if (isBlocked) {
+			$.log.warn(`MQTT客户端 ${clientId} 处于拉黑状态，拒绝请求`);
+			return true;
+		}
+	} catch (error) {
+		$.log.error(`检查客户端 ${clientId} 拉黑状态时出错:`, error);
+		// 发生错误时，默认拒绝请求
+		return true;
+	}
+
+	// 初始化或更新消息计数器
+	if (!this.messageCounters[clientId]) {
+		this.messageCounters[clientId] = {
+			count: 1,
+			lastReset: now
+		};
+	} else {
+		// 检查是否需要重置计数器
+		if (now - this.messageCounters[clientId].lastReset > config.time_window) {
+			this.messageCounters[clientId].count = 1;
+			this.messageCounters[clientId].lastReset = now;
+		} else {
+			// 增加消息计数
+			this.messageCounters[clientId].count++;
+		}
+	}
+
+	// 检查是否超过频率限制
+	if (this.messageCounters[clientId].count > config.max_messages) {
+		// 拉黑客户端 - 使用新的异步函数
+		try {
+			await this.addClientToBlacklist(clientId, config.block_duration);
+		} catch (error) {
+			$.log.error(`拉黑高频请求客户端 ${clientId} 时出错:`, error);
+		}
+		return true;
+	}
+
+	// 正常请求
+	return false;
+};
+
+/**
+ * 异步拉黑客户端并断开连接
+ * @param {Object} client 客户端对象
+ */
+MQTT.prototype.blockClient = async function (client) {
+	const clientId = client.id;
+	const now = Date.now();
+	const config = this.config.rate_limit;
+
+	try {
+		// 使用新的异步函数添加到黑名单
+		await this.addClientToBlacklist(clientId, config.block_duration);
+	} catch (error) {
+		$.log.error(`拉黑MQTT客户端 ${clientId} 时出错:`, error);
+	}
+
+	// 断开客户端连接
+	if (client && client.close) {
+		try {
+			client.close();
+		} catch (error) {
+			$.log.error(`断开MQTT客户端 ${clientId} 连接时出错:`, error);
+		}
+	}
+};
+
+/**
+ * 异步检测客户端重连行为
+ * @param {Object} client 客户端对象
+ * @returns {Promise<Boolean>} true表示检测到异常重连，false表示正常连接
+ */
+MQTT.prototype.detectReconnectAbuse = async function (client) {
+	try {
+		const clientId = client.id;
+		const now = Date.now();
+		const config = this.config.reconnect_detection;
+
+		// 从client对象中获取IP（这里可能需要根据实际情况调整获取IP的方式）
+		const clientIp = client.connection.stream.remoteAddress || 'unknown';
+
+		// 检查IP是否被禁止（使用新的异步函数）
+		const isIpBanned = await this.isIpBanned(clientIp);
+		if (isIpBanned) {
+			$.log.warn(`IP ${clientIp} 处于禁止状态，拒绝连接请求`);
+			return true;
+		}
+
+		// 检查是否是首次连接
+		if (!this.clientHistory[clientId]) {
+			// 首次连接，初始化连接历史
+			this.clientHistory[clientId] = {
+				ip: clientIp,
+				connectCount: 1,
+				lastConnectTime: now,
+				disconnectTime: null,
+				reconnectAttempts: 0
+			};
+			return false;
+		}
+
+		// 获取客户端历史记录
+		const history = this.clientHistory[clientId];
+
+		// 检查是否是来自不同IP的连接
+		if (history.ip !== clientIp) {
+			$.log.warn(`检测到客户端ID ${clientId} 从不同IP连接: 原IP ${history.ip}, 新IP ${clientIp}`);
+
+			// 记录新IP的连接行为
+			const oldIp = history.ip;
+			history.ip = clientIp;
+			history.connectCount++;
+			history.lastConnectTime = now;
+
+			// 禁止新IP连接 - 使用新的异步函数
+			try {
+				await this.addIpToBanlist(clientIp, config.ip_ban_duration);
+			} catch (error) {
+				$.log.error(`禁止IP ${clientIp} 时出错:`, error);
+			}
+			return true;
+		}
+
+		// 检查是否在短时间内频繁重连
+		const timeSinceLastConnect = now - history.lastConnectTime;
+
+		// 如果两次连接间隔很短，增加重连尝试计数
+		if (timeSinceLastConnect < config.frequent_reconnect_threshold) {
+			history.reconnectAttempts++;
+		} else {
+			// 重置重连计数
+			history.reconnectAttempts = 0;
+		}
+
+		// 更新连接计数和时间
+		history.connectCount++;
+		history.lastConnectTime = now;
+
+		// 检查是否超过最大重连尝试次数
+		if (history.reconnectAttempts > config.max_reconnect_attempts) {
+			$.log.warn(`客户端 ${clientId} 重连过于频繁，已尝试 ${history.reconnectAttempts} 次重连`);
+
+			// 禁止该客户端ID重连 - 使用新的异步函数
+			try {
+				await this.addClientToBlacklist(clientId, config.client_id_ban_duration);
+			} catch (error) {
+				$.log.error(`禁止频繁重连客户端 ${clientId} 时出错:`, error);
+			}
+			return true;
+		}
+
+		// 正常连接
+		return false;
+	} catch (error) {
+		$.log.error(`检测客户端 ${client.id} 重连行为时出错:`, error);
+		// 出错时默认视为正常连接，避免误判
+		return false;
+	}
+};
 
 /**
  * 运行
  * @param {String} state 状态
  */
-MQTT.prototype.run = async function(state = 'start') {
+MQTT.prototype.run = async function (state = 'start') {
 	await this.before(state);
 	await this.main(state);
 	await this.after(state);
 };
 
+/**
+ * 异步检查客户端是否被拉黑
+ * @param {String} clientId 客户端ID
+ * @returns {Promise<Boolean>} true表示被拉黑，false表示未被拉黑
+ */
+MQTT.prototype.isClientBlocked = async function (clientId) {
+	const now = Date.now();
+	let isBlocked = false;
+	let unblockTime = null;
+
+	try {
+		// 根据存储类型选择不同的实现方式
+		if (this.blacklistStorageType === 'memory') {
+			// 内存存储方式
+			if (this.blockedClients[clientId]) {
+				unblockTime = this.blockedClients[clientId];
+				isBlocked = now < unblockTime;
+				// 如果已过期，自动移除
+				if (!isBlocked) {
+					delete this.blockedClients[clientId];
+					$.log.info(`MQTT客户端 ${clientId} 解除拉黑`);
+				}
+			}
+		} else {
+			// 其他存储方式（redis、mongodb、mysql）可以在这里扩展实现
+			// 目前仅实现内存存储，其他存储方式需要根据实际需求补充
+			$.log.warn(`黑名单存储类型 ${this.blacklistStorageType} 尚未实现，默认使用内存存储`);
+			if (this.blockedClients[clientId]) {
+				unblockTime = this.blockedClients[clientId];
+				isBlocked = now < unblockTime;
+			}
+		}
+	} catch (error) {
+		$.log.error(`检查客户端 ${clientId} 是否被拉黑时出错:`, error);
+		// 出错时默认视为未被拉黑
+	}
+
+	return isBlocked;
+};
+
+/**
+ * 异步添加客户端到黑名单
+ * @param {String} clientId 客户端ID
+ * @param {Number} duration 拉黑时长（毫秒）
+ * @returns {Promise<Boolean>} true表示添加成功，false表示添加失败
+ */
+MQTT.prototype.addClientToBlacklist = async function (clientId, duration) {
+	const now = Date.now();
+	const unblockTime = now + (duration || this.config.rate_limit.block_duration);
+
+	try {
+		// 根据存储类型选择不同的实现方式
+		if (this.blacklistStorageType === 'memory') {
+			// 内存存储方式
+			this.blockedClients[clientId] = unblockTime;
+		} else {
+			// 其他存储方式（redis、mongodb、mysql）可以在这里扩展实现
+			// 目前仅实现内存存储，其他存储方式需要根据实际需求补充
+			$.log.warn(`黑名单存储类型 ${this.blacklistStorageType} 尚未实现，默认使用内存存储`);
+			this.blockedClients[clientId] = unblockTime;
+		}
+
+		$.log.warn(`MQTT客户端 ${clientId} 被添加到黑名单，限制时长: ${duration / 3600000}小时`);
+		return true;
+	} catch (error) {
+		$.log.error(`添加客户端 ${clientId} 到黑名单时出错:`, error);
+		return false;
+	}
+};
+
+/**
+ * 异步检查IP是否被禁止
+ * @param {String} ip IP地址
+ * @returns {Promise<Boolean>} true表示被禁止，false表示未被禁止
+ */
+MQTT.prototype.isIpBanned = async function (ip) {
+	const now = Date.now();
+	let isBanned = false;
+	let unbanTime = null;
+
+	try {
+		// 根据存储类型选择不同的实现方式
+		if (this.blacklistStorageType === 'memory') {
+			// 内存存储方式
+			if (this.bannedIps[ip]) {
+				unbanTime = this.bannedIps[ip];
+				isBanned = now < unbanTime;
+				// 如果已过期，自动移除
+				if (!isBanned) {
+					delete this.bannedIps[ip];
+					$.log.info(`IP ${ip} 解除禁止`);
+				}
+			}
+		} else {
+			// 其他存储方式（redis、mongodb、mysql）可以在这里扩展实现
+			// 目前仅实现内存存储，其他存储方式需要根据实际需求补充
+			$.log.warn(`黑名单存储类型 ${this.blacklistStorageType} 尚未实现，默认使用内存存储`);
+			if (this.bannedIps[ip]) {
+				unbanTime = this.bannedIps[ip];
+				isBanned = now < unbanTime;
+			}
+		}
+	} catch (error) {
+		$.log.error(`检查IP ${ip} 是否被禁止时出错:`, error);
+		// 出错时默认视为未被禁止
+	}
+
+	return isBanned;
+};
+
+/**
+ * 异步添加IP到禁止列表
+ * @param {String} ip IP地址
+ * @param {Number} duration 禁止时长（毫秒）
+ * @returns {Promise<Boolean>} true表示添加成功，false表示添加失败
+ */
+MQTT.prototype.addIpToBanlist = async function (ip, duration) {
+	const now = Date.now();
+	const unbanTime = now + (duration || this.config.reconnect_detection.ip_ban_duration);
+
+	try {
+		// 根据存储类型选择不同的实现方式
+		if (this.blacklistStorageType === 'memory') {
+			// 内存存储方式
+			this.bannedIps[ip] = unbanTime;
+		} else {
+			// 其他存储方式（redis、mongodb、mysql）可以在这里扩展实现
+			// 目前仅实现内存存储，其他存储方式需要根据实际需求补充
+			$.log.warn(`黑名单存储类型 ${this.blacklistStorageType} 尚未实现，默认使用内存存储`);
+			this.bannedIps[ip] = unbanTime;
+		}
+
+		$.log.warn(`IP ${ip} 被添加到禁止列表，限制时长: ${duration / 3600000}小时`);
+		return true;
+	} catch (error) {
+		$.log.error(`添加IP ${ip} 到禁止列表时出错:`, error);
+		return false;
+	}
+};
+
 module.exports = MQTT;

package/core/com/app/index.js

@@ -56,6 +56,7 @@ App.prototype.update_config_all = async function(path, accurate) {
 			}
 		}
 		dir_app = (path + "/app/").fullname();
+		dir_app.addDir();
 	}
 	
 	if (dir_app.hasDir()) {

package/core/com/plugin/drive.js

@@ -1,6 +1,5 @@
 const compressing = require('compressing');
 const Item = require('mm_machine').Item;
-const Log = require('./log.js');
 const conf = require('mm_config');
 
 /**
@@ -86,12 +85,6 @@ Drive.prototype.set_config = function(config) {
  * 插件初始化之后
  */
 Drive.prototype.set_config_after = function() {
-	var file = this.filename;
-	var filename = file.replace('app', 'log').replace($.slash + 'plugin', '').replace('json', 'log').replace($
-		.slash + 'plugin.log', '.log');
-	this.log = new Log({
-		filename
-	});
 	var options = this.get_config_options();
 	this.options = this.merge_options(options);
 	this.backup_options();

package/index.js

@@ -43,8 +43,8 @@ class OS {
 				"static_path": "./static",
 				"proxy": {},
 				"rateLimit": {
-					"windowMs": 15 * 60 * 1000, // 时间窗口，默认15分钟
-					"maxRequests": 100,         // 每个时间窗口内的最大请求数
+					"windowMs": 60 * 1000, // 时间窗口，默认15分钟
+					"maxRequests": 5000,         // 每个时间窗口内的最大请求数
 					"message": "请求过于频繁，请稍后再试", // 超过限制时的提示信息
 					"statusCode": 429           // 超过限制时的HTTP状态码
 				}

package/middleware/rate_limit/index.js

@@ -8,12 +8,14 @@ module.exports = function(server, config) {
     // 初始化速率限制配置
     const cg = {
         // 默认配置
-        windowMs: 15 * 60 * 1000, // 时间窗口，默认15分钟
-        maxRequests: 100,         // 每个时间窗口内的最大请求数
+        windowMs: 60 * 1000,      // 时间窗口，调整为1分钟（更精细的限制）
+        maxRequests: 5000,         // 每个时间窗口内的最大请求数，从1000提高到5000
         message: '请求过于频繁，请稍后再试', // 超过限制时的提示信息
         statusCode: 429,          // 超过限制时的HTTP状态码
+        // 白名单路径，这些路径不受速率限制
+        whitelistPaths: [],
         // 合并用户配置
-        ...(config && config.rateLimit ? config.rateLimit : {})
+        ...(config && config.rate_limit ? config.rate_limit : {})
     };
     
     // 生成基于IP的唯一标识符
@@ -60,6 +62,13 @@ module.exports = function(server, config) {
                 return;
             }
             
+            // 检查是否是白名单路径
+            if (cg.whitelistPaths && cg.whitelistPaths.some(path => 
+                ctx.path === path || ctx.path.startsWith(path + '/'))) {
+                await next();
+                return;
+            }
+            
             // 获取客户端唯一标识符
             const clientKey = getClientKey(ctx);
             

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mm_os",
-	"version": "3.2.6",
+	"version": "3.2.8",
 	"description": "这是超级美眉服务端框架，用于快速构建应用程序。",
 	"main": "index.js",
 	"scripts": {