mm_os 3.2.9 → 3.3.1

package/core/base/mqtt/index.js

@@ -1,1107 +1,1110 @@
-require('./lib.js');
-const mosca = require('mosca');
-
-/**
- * mqtt 物联网通讯类
- */
-class MQTT {
-	/**
-	 * 构造函数
-	 * @param {Object} config 配置参数
-	 */
-	constructor(config) {
-		this.config = Object.assign({
-			"state": true,
-			// mqtt访问端口号
-			"socket_port": 1883,
-			// 服务端
-			"http_host": "localhost",
-			// websocket 访问端口
-			"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,
-				password: "asd159357",
-				db: 12
-			},
-			mongodb: {
-				user: "",
-				password: "",
-				host: "localhost",
-				port: 27017,
-				database: "mqtt"
-			}
-		}, config);
-
-		/**
-		 * 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) {
-	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) {
-	if (config) {
-		this.config = Object.assign(this.config, config);
-	}
-	var cg = Object.assign({}, this.config);
-	var {
-		redis,
-		mongodb
-	} = cg;
-	var conf = {
-		port: cg.socket_port,
-		http: {
-			host: cg.http_host || "localhost",
-			port: cg.http_port,
-			bundle: true,
-			static: './'
-		}
-	}
-	if (cg.cache === 'redis') {
-		if (cg.redis) {
-			conf.backend = {
-				type: "redis",
-				redis: require('redis'),
-				host: redis.host || "localhost",
-				port: redis.port || 6379,
-				password: redis.password,
-				db: redis.db || 12,
-				return_buffers: true
-			}
-		} else {
-			conf.backend = {
-				type: "redis",
-				redis: require('redis'),
-				host: "localhost",
-				password: "asd159357",
-				port: 6379,
-				db: 12,
-				return_buffers: true
-			}
-		}
-		// 数据持久化参数设置
-		conf.persistence = Object.assign({
-			factory: mosca.persistence.Redis,
-			ttl: {
-				// 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}`;
-		}
-		conf.backend = {
-			// 增加了此项
-			type: 'mongo',
-			url,
-			pubsubCollection: 'ascoltatori',
-			mongo: {}
-		};
-
-		// 数据持久化参数设置
-		conf.persistence = Object.assign({
-			factory: mosca.persistence.Mongo,
-			ttl: {
-				// TTL for subscriptions
-				subscriptions: cg.message_retention * 1000, // 恢复为毫秒
-				// TTL for packets
-				packets: cg.message_retention * 1000, // 恢复为毫秒
-			}
-		}, conf.backend);
-	}
-	this.server = new mosca.Server(conf);
-	return this;
-};
-
-/**
- * 引用
- * @param {Function} 函数
- */
-MQTT.prototype.use = function (func) {
-	// this.server.use(func);
-};
-
-/**
- * 运行主程序
- * @param {String} state 状态
- */
-MQTT.prototype.main = function (state) {
-	var cg = this.config;
-	var sr = this.server;
-
-	var _this = this;
-
-	/**
-	 * 对服务器端口进行配置，在此端口进行监听
-	 * @param {Object} client 客户端信息
-	 */
-	sr.on('clientConnected', async function (client) {
-		return await _this.connected(client);
-	});
-
-	/**
-	 * 监听MQTT主题消息
-	 * @param {Object} packet 订阅消息
-	 * @param {Object} 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);
-	});
-
-	/**
-	 * 监听MQTT主题消息
-	 * @param {String} topic 订阅主题
-	 * @param {Object} client 客户端信息
-	 */
-	sr.on('subscribed', function (topic, client) {
-		_this.subscribed(topic, client);
-	});
-
-	/**
-	 * 身份验证
-	 */
-	sr.authenticate = (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) => {
-		const isAllowed = this.authPublish(client, topic, payload);
-		callback(null, isAllowed);
-		return true;
-	};
-
-	/**
-	 * 验证订阅，决定客户端可以订阅哪些主题
-	 */
-	sr.authorizeSubscribe = (client, topic, callback) => {
-		const isAllowed = this.authSubscribe(client, topic);
-		callback(null, isAllowed);
-		return true;
-	};
-
-
-	/**
-	 * 当服务开启时
-	 */
-	sr.on('ready', function () {
-		// 当服务开启时
-		$.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);
-	});
-}
-
-/**
- * 收到订阅时
- * @param {String} topic 订阅主题
- * @param {Object} 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) {
-	// console.log("发布", packet.topic, packet.payload.toString());
-};
-
-/**
-	 * 身份验证 - 主要入口函数
-	 * @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} 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} password 密码字符串
- * @param {Function} callback 回调函数
- */
-MQTT.prototype.checkAccount = async function (client, username, password, callback) {
-	if (!username || !password) {
-		return;
-	}
-	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);
-				}
-			}
-			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}`);
-				}
-			}
-		}
-	}
-	catch (err) {
-		$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
-	}
-	callback(null, false);
-}
-
-/**
- * 验证发布，决定客户端可以发布哪些主题
- * @param {Object} client 客户端
- * @param {String} topic 主题
- * @param {Object} payload 参数
- * @returns {Boolean} true表示验证通过，false表示验证失败
- */
-MQTT.prototype.authPublish = function (client, topic, payload) {
-	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
-	// 在实际应用中，应该从数据库或配置中获取客户端的发布权限
-	let isAllowed = true;
-
-	// 例如：限制某些敏感主题只能由管理员发布
-	const isSensitiveTopic = (this.config.sensitiveTopics || []).some(sensitiveTopic =>
-		topic === sensitiveTopic || topic.startsWith(sensitiveTopic + '/')
-	);
-
-	// 简单示例：检查客户端ID是否表示管理员客户端
-	const isAdminClient = client.id === 'admin' || client.id.startsWith('server_');
-
-	if (isSensitiveTopic && !isAdminClient) {
-		isAllowed = false;
-		$.log.warn(`MQTT客户端 ${client.id} 被拒绝发布到敏感主题: ${topic}`);
-	}
-
-	return isAllowed;
-};
-
-/**
- * 验证订阅，决定客户端可以订阅哪些主题
- * @param {Object} client 客户端
- * @param {String} topic 主题
- * @returns {Boolean} true表示验证通过，false表示验证失败
- */
-MQTT.prototype.authSubscribe = function (client, topic) {
-	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
-	// 在实际应用中，应该从数据库或配置中获取客户端的订阅权限
-	let isAllowed = true;
-
-	// 例如：限制某些敏感主题只能由特定客户端订阅
-	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 isAllowedClient = (this.config.allowedClients || []).includes(client.id);
-
-	if (isRestrictedTopic && !isAllowedClient) {
-		isAllowed = false;
-		$.log.warn(`MQTT客户端 ${client.id} 被拒绝订阅受限主题: ${topic}`);
-	}
-
-	return isAllowed;
-};
-
-/**
- * 运行主程序前
- * @param {String} state 状态
- */
-MQTT.prototype.before = async function (state) {
-	var list = this.list;
-	for (var i = 0; i < list.length; i++) {
-		var o = list[i];
-		o.func = require(o.func_file);
-		if (o.func) {
-			o.func(this.server, this.config);
-		}
-	}
-};
-
-/**
- * 运行主程序后
- * @param {String} 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') {
-	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;
-	}
-};
-
+require('./lib.js');
+const mosca = require('mosca');
+
+/**
+ * mqtt 物联网通讯类
+ */
+class MQTT {
+	/**
+	 * 构造函数
+	 * @param {Object} config 配置参数
+	 */
+	constructor(config) {
+		this.config = Object.assign({
+			"state": true,
+			// mqtt访问端口号
+			"socket_port": 1883,
+			// 服务端
+			"http_host": "localhost",
+			// websocket 访问端口
+			"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,
+				password: "asd159357",
+				db: 12
+			},
+			mongodb: {
+				user: "",
+				password: "",
+				host: "localhost",
+				port: 27017,
+				database: "mqtt"
+			}
+		}, config);
+
+		/**
+		 * 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) {
+	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) {
+	if (config) {
+		this.config = Object.assign(this.config, config);
+	}
+	var cg = Object.assign({}, this.config);
+	var {
+		redis,
+		mongodb
+	} = cg;
+	var conf = {
+		port: cg.socket_port,
+		http: {
+			host: cg.http_host || "localhost",
+			port: cg.http_port,
+			bundle: true,
+			static: './'
+		}
+	}
+	if (cg.cache === 'redis') {
+		if (cg.redis) {
+			conf.backend = {
+				type: "redis",
+				redis: require('redis'),
+				host: redis.host || "localhost",
+				port: redis.port || 6379,
+				password: redis.password,
+				db: redis.db || 12,
+				return_buffers: true
+			}
+		} else {
+			conf.backend = {
+				type: "redis",
+				redis: require('redis'),
+				host: "localhost",
+				password: "asd159357",
+				port: 6379,
+				db: 12,
+				return_buffers: true
+			}
+		}
+		// 数据持久化参数设置
+		conf.persistence = Object.assign({
+			factory: mosca.persistence.Redis,
+			ttl: {
+				// 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}`;
+		}
+		conf.backend = {
+			// 增加了此项
+			type: 'mongo',
+			url,
+			pubsubCollection: 'ascoltatori',
+			mongo: {}
+		};
+
+		// 数据持久化参数设置
+		conf.persistence = Object.assign({
+			factory: mosca.persistence.Mongo,
+			ttl: {
+				// TTL for subscriptions
+				subscriptions: cg.message_retention * 1000, // 恢复为毫秒
+				// TTL for packets
+				packets: cg.message_retention * 1000, // 恢复为毫秒
+			}
+		}, conf.backend);
+	}
+	this.server = new mosca.Server(conf);
+	return this;
+};
+
+/**
+ * 引用
+ * @param {Function} 函数
+ */
+MQTT.prototype.use = function(func) {
+	// this.server.use(func);
+};
+
+/**
+ * 运行主程序
+ * @param {String} state 状态
+ */
+MQTT.prototype.main = function(state) {
+	var cg = this.config;
+	var sr = this.server;
+
+	var _this = this;
+
+	/**
+	 * 对服务器端口进行配置，在此端口进行监听
+	 * @param {Object} client 客户端信息
+	 */
+	sr.on('clientConnected', async function(client) {
+		return await _this.connected(client);
+	});
+
+	/**
+	 * 监听MQTT主题消息
+	 * @param {Object} packet 订阅消息
+	 * @param {Object} 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);
+	});
+
+	/**
+	 * 监听MQTT主题消息
+	 * @param {String} topic 订阅主题
+	 * @param {Object} client 客户端信息
+	 */
+	sr.on('subscribed', function(topic, client) {
+		_this.subscribed(topic, client);
+	});
+
+	/**
+	 * 身份验证
+	 */
+	sr.authenticate = (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) => {
+		const isAllowed = this.authPublish(client, topic, payload);
+		callback(null, isAllowed);
+		return true;
+	};
+
+	/**
+	 * 验证订阅，决定客户端可以订阅哪些主题
+	 */
+	sr.authorizeSubscribe = (client, topic, callback) => {
+		const isAllowed = this.authSubscribe(client, topic);
+		callback(null, isAllowed);
+		return true;
+	};
+
+
+	/**
+	 * 当服务开启时
+	 */
+	sr.on('ready', function() {
+		// 当服务开启时
+		$.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);
+	});
+}
+
+/**
+ * 收到订阅时
+ * @param {String} topic 订阅主题
+ * @param {Object} 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) {
+	// console.log("发布", packet.topic, packet.payload.toString());
+};
+
+/**
+ * 身份验证 - 主要入口函数
+ * @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} 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} password 密码字符串
+ * @param {Function} callback 回调函数
+ */
+MQTT.prototype.checkAccount = async function(client, username, password, callback) {
+	if (!username || !password) {
+		return;
+	}
+	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);
+				}
+			} 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}`);
+				}
+			}
+		}
+	} catch (err) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
+	}
+	callback(null, false);
+}
+
+/**
+ * 验证发布，决定客户端可以发布哪些主题
+ * @param {Object} client 客户端
+ * @param {String} topic 主题
+ * @param {Object} payload 参数
+ * @returns {Boolean} true表示验证通过，false表示验证失败
+ */
+MQTT.prototype.authPublish = function(client, topic, payload) {
+	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
+	// 在实际应用中，应该从数据库或配置中获取客户端的发布权限
+	let isAllowed = true;
+
+	// 例如：限制某些敏感主题只能由管理员发布
+	const isSensitiveTopic = (this.config.sensitiveTopics || []).some(sensitiveTopic =>
+		topic === sensitiveTopic || topic.startsWith(sensitiveTopic + '/')
+	);
+
+	// 简单示例：检查客户端ID是否表示管理员客户端
+	const isAdminClient = client.id === 'admin' || client.id.startsWith('server_');
+
+	if (isSensitiveTopic && !isAdminClient) {
+		isAllowed = false;
+		$.log.warn(`MQTT客户端 ${client.id} 被拒绝发布到敏感主题: ${topic}`);
+	}
+
+	return isAllowed;
+};
+
+/**
+ * 验证订阅，决定客户端可以订阅哪些主题
+ * @param {Object} client 客户端
+ * @param {String} topic 主题
+ * @returns {Boolean} true表示验证通过，false表示验证失败
+ */
+MQTT.prototype.authSubscribe = function(client, topic) {
+	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
+	// 在实际应用中，应该从数据库或配置中获取客户端的订阅权限
+	let isAllowed = true;
+
+	// 例如：限制某些敏感主题只能由特定客户端订阅
+	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 isAllowedClient = (this.config.allowedClients || []).includes(client.id);
+
+	if (isRestrictedTopic && !isAllowedClient) {
+		isAllowed = false;
+		$.log.warn(`MQTT客户端 ${client.id} 被拒绝订阅受限主题: ${topic}`);
+	}
+
+	return isAllowed;
+};
+
+/**
+ * 运行主程序前
+ * @param {String} state 状态
+ */
+MQTT.prototype.before = async function(state) {
+	var list = this.list;
+	for (var i = 0; i < list.length; i++) {
+		var o = list[i];
+		o.func = require(o.func_file);
+		if (o.func) {
+			o.func(this.server, this.config);
+		}
+	}
+};
+
+/**
+ * 运行主程序后
+ * @param {String} 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.addBlacklist(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.addBlacklist(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.addBlacklist(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.addBlacklist(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') {
+	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.addBlacklist = 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.removeBlacklist = 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;