mm_os 3.2.7 → 3.2.9

package/core/base/mqtt/index.js

@@ -10,9 +10,6 @@ class MQTT {
 	 * @param {Object} config 配置参数
 	 */
 	constructor(config) {
-		/**
-		 * 配置参数
-		 */
 		this.config = Object.assign({
 			"state": true,
 			// mqtt访问端口号
@@ -23,6 +20,34 @@ class MQTT {
 			"http_port": 8083,
 			// 缓存方式
 			"cache": "mongodb", // "mongodb",
+			// 消息保留时长(秒)
+			"message_retention": 86400,
+			// 消息频率限制配置
+			"rate_limit": {
+				// 时间窗口（秒）
+				"time_window": 60, // 默认1分钟
+				// 时间窗口内允许的最大消息数
+				"max_messages": 100,  // 人脸识别门禁优化：1分钟内最多20条消息（门禁通常每次识别仅发送1-3条消息）
+				// 拉黑时长（秒）
+				"block_duration": 3600 // 人脸识别门禁优化：拉黑30分钟（更合理的临时限制时长）
+			},
+			// 安全配置 - 扁平化且共用参数
+			// 通用安全配置
+			"time_window": 60, // 时间窗口（秒）- 共用参数
+			"max_attempts": 5, // 最大尝试次数 - 共用参数
+			"block_duration": 3600, // 默认拉黑时长（秒）- 共用参数
+			// 重连检测特定配置
+			"reconnect_ip_duration": 3600, // 同一客户端ID不同IP的禁止时间（秒）
+			"reconnect_client_duration": 7200, // 客户端ID禁止重连时间（秒）
+			"reconnect_frequency_threshold": 30, // 频繁重连时间阈值（秒）
+			// 密码尝试特定配置
+			"password_block_ip": true, // 密码错误时是否同时拉黑IP
+			// 受限主题列表，用于限制某些敏感主题只能由特定客户端订阅
+			restrictedTopics: [],
+			// 允许订阅受限主题的客户端列表
+			allowedClients: [],
+			// 敏感主题列表，用于限制某些敏感主题只能由管理员发布
+			sensitiveTopics: [],
 			redis: {
 				host: "localhost",
 				port: 6379,
@@ -44,24 +69,82 @@ class MQTT {
 		this.server = null;
 
 		this.list = [];
+
+		/**
+		 * 客户端消息计数器
+		 * 格式: { clientId: { count: 消息数, lastReset: 上次重置时间戳 } }
+		 */
+		this.messageCounters = {};
+
+		/**
+		 * 拉黑的客户端列表
+		 * 格式: { clientId: 解除拉黑时间戳 }
+		 */
+		this.blockedClients = {};
+
+		/**
+		 * 被禁止的IP列表
+		 * 格式: { ip: 解除禁止时间戳 }
+		 */
+		this.bannedIps = {};
+
+		/**
+		 * 安全记录（合并客户端连接历史和密码错误记录）
+		 * 格式: {
+		 *   client: { clientId: { ip: 客户端IP, connectCount: 连接次数, lastConnectTime: 上次连接时间, disconnectTime: 上次断开时间, reconnectAttempts: 重连尝试次数 } },
+		 *   password: { username: { count: 错误次数, firstAttempt: 首次尝试时间, lastAttempt: 上次尝试时间, ip: 尝试IP } }
+		 * }
+		 */
+		this.securityRecords = {
+			client: {},
+			password: {}
+		};
+
+		/**
+		 * 黑名单存储类型
+		 * 可选值: '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,17 +188,17 @@ 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') {
 		var url = `mongodb://${mongodb.host}:${mongodb.port}/${mongodb.database}`;
 		if (mongodb.user) {
 			url =
-				`mongodb://${mongodb.user}:${mongodb.password}@${mongodb.host}:${mongodb.port}/${mongodb.database}`
+				`mongodb://${mongodb.user}:${mongodb.password}@${mongodb.host}:${mongodb.port}/${mongodb.database}`;
 		}
 		conf.backend = {
 			// 增加了此项
@@ -123,16 +206,16 @@ MQTT.prototype.init = function(config) {
 			url,
 			pubsubCollection: 'ascoltatori',
 			mongo: {}
-		}
+		};
 
 		// 数据持久化参数设置
 		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 +227,7 @@ MQTT.prototype.init = function(config) {
  * 引用
  * @param {Function} 函数
  */
-MQTT.prototype.use = function(func) {
+MQTT.prototype.use = function (func) {
 	// this.server.use(func);
 };
 
@@ -152,7 +235,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 +245,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 +281,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);
 	});
 
@@ -188,35 +289,56 @@ MQTT.prototype.main = function(state) {
 	 * 身份验证
 	 */
 	sr.authenticate = (client, username, password, callback) => {
-		$.log.info("收到身份验证", username, password);
-		this.auth(client, username, password, callback);
+		// 正确获取客户端IP地址
+		const clientIp = client.connection && client.connection.stream ? client.connection.stream.remoteAddress || 'unknown' : 'unknown';
+		$.log.info("收到身份验证", clientIp, client.id, username);
+		// 因为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,165 +347,259 @@ 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.securityRecords.client[clientId]) {
+		this.securityRecords.client[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 = async function (client, username, password, callback) {
+	try {
+		// 检查客户端状态（拉黑、异常重连等）- 现在是异步操作
+		const clientStatusResult = await this.checkClientStatus(client);
+		if (clientStatusResult === false) {
+			callback(null, false);
+			return;
+		}
+
+		// 密码可能是Buffer类型，需要转换为字符串
+		const passwordStr = password ? password.toString() : '';
+
+		// 验证凭证格式
+		const credentialsResult = this.validateCredentials(client, username, passwordStr);
+		if (credentialsResult === false) {
+			callback(null, false);
+			return;
+		}
+
+		// 检查密码错误次数限制（防暴力破解）
+		const passwordLimitResult = await this.checkPasswordAttemptLimit(client, username);
+		if (passwordLimitResult === false) {
+			callback(null, false);
+			return;
+		}
+
+		// 查询用户密码并验证（异步操作，需要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内部也有黑名单相关操作，后续可以考虑重构为使用异步函数
+		const hasReconnectAbuse = await this.detectReconnectAbuse(client);
+		if (hasReconnectAbuse) {
+			$.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} password 密码
- * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
+ * @param {String} passwordStr 密码字符串
+ * @returns {Boolean} true表示凭证格式有效，false表示凭证格式无效
  */
-MQTT.prototype.auth = function(client, username, password, callback) {
-	// 密码可能是Buffer类型，需要转换为字符串
-	const passwordStr = password ? password.toString() : '';
-	
+MQTT.prototype.validateCredentials = function (client, username, passwordStr) {
 	// 检查必要参数
 	if (!username || !passwordStr) {
-		console.warn(`MQTT客户端 ${client.id} 身份验证失败：用户名或密码为空`);
-		callback(null, false);
-		return;
+		$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：用户名或密码为空`);
+		return false;
 	}
-	
+
 	// 检查是否有可用的MySQL连接
-	if (!$.sql || typeof $.sql.query !== 'function') {
-		console.error(`MQTT客户端 ${client.id} 身份验证错误：MySQL连接不可用`);
-		callback(null, false);
+	if (!$.mysql_admin) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证错误：MySQL连接不可用`);
+		return false;
+	}
+
+	return true;
+};
+
+/**
+ * 查询用户密码并验证
+ * @param {Object} client 客户端
+ * @param {String} username 用户名
+ * @param {String} password 密码字符串
+ * @param {Function} callback 回调函数
+ */
+MQTT.prototype.checkAccount = async function (client, username, password, callback) {
+	if (!username || !password) {
 		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);
-			callback(null, false);
-			return;
-		}
-		
-		// 检查用户是否存在
-		if (!results || results.length === 0) {
-			console.warn(`MQTT客户端 ${client.id} 身份验证失败：用户不存在，用户名: ${username}`);
-			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}`);
+	var sql = $.mysql_admin('sys');
+	try {
+		var dbs = sql.db();
+		// 先尝试通过客户端ID和用户名精确匹配
+
+		// 判断设备连接
+		var db1 = dbs.new(this.config.table_name || 'face_device', "");
+		var obj = await db1.getObj({
+			username,
+			clientid: client.id
+		});
+		if (obj) {
+			if (obj.available && obj.state) {
+				if (obj.password == password) {
+					// 账号密码正确
+					return callback(null, true);
+				}
+				else {
+					$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：密码错误，用户名: ${username}`);
+					// 记录密码错误尝试
+					await this.recordPasswordFailure(client, 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}`);
+			else {
+				$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：账户不可用，用户名: ${username}`);
+			}
+		} else {
+			// 判断应用连接
+			var db2 = dbs.new("sys_app", "app_id");
+			var o = await db2.getObj({
+				appid: username
+			});
+			if (o) {
+				if (o.available) {
+					if (o.appsecret == password) {
+						// 账号密码正确
+						return callback(null, true);
+					}
+					else {
+						$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：密码错误，用户名: ${username}`);
+						// 记录密码错误尝试
+						await this.recordPasswordFailure(client, username);
+					}
+				}
+				else {
+					$.log.warn(`MQTT客户端 ${client.id} 身份验证失败：账户不可用，用户名: ${username}`);
+				}
 			}
-			
-			callback(null, isMatch);
 		}
-	});
-};
+	}
+	catch (err) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
+	}
+	callback(null, false);
+}
 
 /**
  * 验证发布，决定客户端可以发布哪些主题
  * @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 +614,494 @@ 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 {
+		// 检查是否需要重置计数器（注意：time_window现在是秒，需要转换为毫秒进行比较）
+		if (now - this.messageCounters[clientId].lastReset > config.time_window * 1000) {
+			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;
+
+			// 从client对象中获取IP
+			const clientIp = client.connection && client.connection.stream ? client.connection.stream.remoteAddress || 'unknown' : 'unknown';
+
+			// 检查IP是否被禁止
+			const isIpBanned = await this.isIpBanned(clientIp);
+			if (isIpBanned) {
+				$.log.warn(`IP ${clientIp} 处于禁止状态，拒绝连接请求`);
+				return true;
+			}
+
+			// 检查是否是首次连接
+			if (!this.securityRecords.client[clientId]) {
+				// 首次连接，初始化连接历史
+				this.securityRecords.client[clientId] = {
+					ip: clientIp,
+					connectCount: 1,
+					lastConnectTime: now,
+					disconnectTime: null,
+					reconnectAttempts: 0
+				};
+				return false;
+			}
+
+			// 获取客户端历史记录
+			const history = this.securityRecords.client[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.reconnect_ip_duration);
+				} catch (error) {
+					$.log.error(`禁止IP ${clientIp} 时出错:`, error);
+				}
+				return true;
+			}
+
+			// 检查是否在短时间内频繁重连
+			const timeSinceLastConnect = now - history.lastConnectTime;
+
+			// 如果两次连接间隔很短，增加重连尝试计数
+			if (timeSinceLastConnect < config.reconnect_frequency_threshold * 1000) {
+				history.reconnectAttempts++;
+			} else {
+				// 重置重连计数
+				history.reconnectAttempts = 0;
+			}
+
+			// 更新连接计数和时间
+				history.connectCount++;
+				history.lastConnectTime = now;
+
+			// 检查是否超过最大重连尝试次数
+			if (history.reconnectAttempts > config.max_attempts) {
+				$.log.warn(`客户端 ${clientId} 重连过于频繁，已尝试 ${history.reconnectAttempts} 次重连`);
+
+				// 禁止该客户端ID重连
+				try {
+					await this.addClientToBlacklist(clientId, config.reconnect_client_duration);
+				} catch (error) {
+					$.log.error(`禁止频繁重连客户端 ${clientId} 时出错:`, error);
+				}
+				return true;
+			}
+
+		// 正常连接
+		return false;
+	} catch (error) {
+		$.log.error(`检测客户端 ${client.id} 重连行为时出错:`, error);
+		// 出错时默认视为正常连接，避免误判
+		return false;
+	}
+};
+
+/**
+ * 异步检查密码尝试次数限制
+ * @param {Object} client 客户端
+ * @param {String} username 用户名
+ * @returns {Promise<Boolean>} true表示未超过限制，false表示已超过限制
+ */
+MQTT.prototype.checkPasswordAttemptLimit = async function (client, username) {
+	try {
+		const now = Date.now();
+			const config = this.config;
+
+			// 从client对象中获取IP
+			const clientIp = client.connection && client.connection.stream ? client.connection.stream.remoteAddress || 'unknown' : 'unknown';
+
+			// 检查用户名是否已被禁止（密码错误次数过多）
+			if (this.securityRecords.password[username]) {
+				const failureRecord = this.securityRecords.password[username];
+				const timeSinceFirstFailure = now - failureRecord.firstAttempt;
+				const timeSinceLastFailure = now - failureRecord.lastAttempt;
+
+				// 如果超过了时间窗口，重置错误计数
+				if (timeSinceFirstFailure > config.time_window * 1000) {
+					// 重置错误计数
+					delete this.securityRecords.password[username];
+					return true;
+				}
+
+				// 检查错误次数是否超过限制
+				if (failureRecord.count >= config.max_attempts) {
+					// 记录被拒绝的尝试
+					$.log.warn(`拒绝客户端 ${client.id} (IP: ${clientIp}) 连接：用户名 ${username} 密码错误次数过多`);
+					return false;
+				}
+			}
+
+		return true;
+	} catch (error) {
+		$.log.error(`检查客户端 ${client.id} 密码尝试次数限制时出错:`, error);
+		// 出错时默认视为未超过限制，避免误判
+		return true;
+	}
+};
+
+/**
+ * 异步记录密码错误尝试
+ * @param {Object} client 客户端
+ * @param {String} username 用户名
+ */
+MQTT.prototype.recordPasswordFailure = async function (client, username) {
+	try {
+		const now = Date.now();
+			const config = this.config;
+
+			// 从client对象中获取IP
+			const clientIp = client.connection && client.connection.stream ? client.connection.stream.remoteAddress || 'unknown' : 'unknown';
+
+			// 初始化或更新密码错误记录
+			if (!this.securityRecords.password[username]) {
+				this.securityRecords.password[username] = {
+					count: 1,
+					firstAttempt: now,
+					lastAttempt: now,
+					ip: clientIp
+				};
+			} else {
+				this.securityRecords.password[username].count++;
+				this.securityRecords.password[username].lastAttempt = now;
+			}
+
+			const failureCount = this.securityRecords.password[username].count;
+			$.log.warn(`MQTT客户端 ${client.id} (IP: ${clientIp}) 密码错误，用户名: ${username}，当前错误次数: ${failureCount}`);
+
+			// 检查是否达到最大错误次数，需要拉黑
+			if (failureCount >= config.max_attempts) {
+				// 拉黑客户端
+				await this.addClientToBlacklist(client.id, config.block_duration);
+				
+				// 如果配置了同时拉黑IP，也拉黑IP
+				if (config.password_block_ip) {
+					await this.addIpToBanlist(clientIp, config.block_duration);
+				}
+
+				$.log.warn(`用户名 ${username} 密码错误次数达到上限(${config.max_attempts}次)，已拉黑客户端 ${client.id} 和IP ${clientIp}，时长 ${config.block_duration / 3600}小时`);
+			}
+
+	} catch (error) {
+		$.log.error(`记录客户端 ${client.id} 密码错误时出错:`, error);
+	}
+};
 
 /**
  * 运行
  * @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) * 1000; // 转换为毫秒
+
+	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 || this.config.rate_limit.block_duration) / 3600}小时`);
+		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_ip_duration) * 1000; // 转换为毫秒
+
+	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 || this.config.reconnect_ip_duration) / 3600}小时`);
+		return true;
+	} catch (error) {
+		$.log.error(`添加IP ${ip} 到禁止列表时出错:`, error);
+		return false;
+	}
+};
+
+/**
+ * 异步从黑名单中移出客户端
+ * @param {String} clientId 客户端ID
+ * @returns {Promise<Boolean>} true表示移出成功，false表示移出失败
+ */
+MQTT.prototype.removeClientFromBlacklist = async function (clientId) {
+	try {
+		// 根据存储类型选择不同的实现方式
+		if (this.blacklistStorageType === 'memory') {
+			// 内存存储方式
+			if (this.blockedClients[clientId]) {
+				delete this.blockedClients[clientId];
+				$.log.info(`MQTT客户端 ${clientId} 已从黑名单中移出`);
+				return true;
+			} else {
+				$.log.info(`MQTT客户端 ${clientId} 不在黑名单中`);
+				return false;
+			}
+		} else {
+			// 其他存储方式（redis、mongodb、mysql）可以在这里扩展实现
+			// 目前仅实现内存存储，其他存储方式需要根据实际需求补充
+			$.log.warn(`黑名单存储类型 ${this.blacklistStorageType} 尚未实现，默认使用内存存储`);
+			if (this.blockedClients[clientId]) {
+				delete this.blockedClients[clientId];
+				$.log.info(`MQTT客户端 ${clientId} 已从黑名单中移出`);
+				return true;
+			} else {
+				$.log.info(`MQTT客户端 ${clientId} 不在黑名单中`);
+				return false;
+			}
+		}
+	} catch (error) {
+		$.log.error(`从黑名单中移出客户端 ${clientId} 时出错:`, error);
+		return false;
+	}
+};
+
+/**
+ * 异步从禁止列表中移出IP
+ * @param {String} ip IP地址
+ * @returns {Promise<Boolean>} true表示移出成功，false表示移出失败
+ */
+MQTT.prototype.removeIpFromBanlist = async function (ip) {
+	try {
+		// 根据存储类型选择不同的实现方式
+		if (this.blacklistStorageType === 'memory') {
+			// 内存存储方式
+			if (this.bannedIps[ip]) {
+				delete this.bannedIps[ip];
+				$.log.info(`IP ${ip} 已从禁止列表中移出`);
+				return true;
+			} else {
+				$.log.info(`IP ${ip} 不在禁止列表中`);
+				return false;
+			}
+		} else {
+			// 其他存储方式（redis、mongodb、mysql）可以在这里扩展实现
+			// 目前仅实现内存存储，其他存储方式需要根据实际需求补充
+			$.log.warn(`黑名单存储类型 ${this.blacklistStorageType} 尚未实现，默认使用内存存储`);
+			if (this.bannedIps[ip]) {
+				delete this.bannedIps[ip];
+				$.log.info(`IP ${ip} 已从禁止列表中移出`);
+				return true;
+			} else {
+				$.log.info(`IP ${ip} 不在禁止列表中`);
+				return false;
+			}
+		}
+	} 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/index.js

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

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,      // 时间窗口，调整为1分钟（更精细的限制）
+        maxRequests: 5000,         // 每个时间窗口内的最大请求数，从1000提高到5000
         message: '请求过于频繁，请稍后再试', // 超过限制时的提示信息
         statusCode: 429,          // 超过限制时的HTTP状态码
+        // 白名单路径，这些路径不受速率限制
+        whitelistPaths: [],
         // 合并用户配置
-        ...(config && config.rateLimit ? config.rateLimit : {})
+        ...(config && config.rate_limit ? config.rate_limit : {})
     };
     
     // 生成基于IP的唯一标识符
@@ -39,7 +41,7 @@ module.exports = function(server, config) {
                 const count = await $.cache.addInt(key, 1);
                 
                 // 设置过期时间
-                await $.cache.ttl(key, Math.ceil(cg.windowMs / 1000));
+                await $.cache.ttl(key, Math.ceil(cg.windowMs));
                 
                 return count || 0;
             }
@@ -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);
             
@@ -97,7 +106,7 @@ module.exports = function(server, config) {
     });
     
     // 记录中间件初始化信息
-    $.log.info(`速率限制中间件已加载: ${cg.maxRequests}请求/${cg.windowMs/1000}秒`);
+    $.log.info(`速率限制中间件已加载: ${cg.maxRequests}请求/${cg.windowMs}秒`);
     
     return server;
 };

package/package.json

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

package/test.js

@@ -1,5 +1,10 @@
 var OS = require("./index.js");
 
+$.sql = $.mysql_admin('sys', __dirname);
+$.sql.config.database = "face";
+$.sql.config.password = "Asd159357";
+$.sql.open();
+
 var os = new OS();
 
 os.run();