mm_os 3.2.8 → 3.3.0

package/core/base/mqtt/index.js

@@ -7,7 +7,7 @@ const mosca = require('mosca');
 class MQTT {
 	/**
 	 * 构造函数
-	 * @param {Object} config 配置参数	
+	 * @param {Object} config 配置参数
 	 */
 	constructor(config) {
 		this.config = Object.assign({
@@ -24,26 +24,24 @@ class MQTT {
 			"message_retention": 86400,
 			// 消息频率限制配置
 			"rate_limit": {
-				// 时间窗口（毫秒）
-				"time_window": 60000, // 默认1分钟
+				// 时间窗口（秒）
+				"time_window": 60, // 默认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秒
+				// 拉黑时长（秒）
+				"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: [],
 			// 允许订阅受限主题的客户端列表
@@ -84,18 +82,24 @@ class MQTT {
 		 */
 		this.blockedClients = {};
 
-		/**
-		 * 客户端连接历史记录
-		 * 格式: { clientId: { ip: 客户端IP, connectCount: 连接次数, lastConnectTime: 上次连接时间, disconnectTime: 上次断开时间, reconnectAttempts: 重连尝试次数 } }
-		 */
-		this.clientHistory = {};
-
 		/**
 		 * 被禁止的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'
@@ -185,16 +189,16 @@ MQTT.prototype.init = function (config) {
 			factory: mosca.persistence.Redis,
 			ttl: {
 				// TTL for subscriptions
-				subscriptions: cg.message_retention * 1000,
+				subscriptions: cg.message_retention * 1000, // 恢复为毫秒
 				// TTL for packets
-				packets: cg.message_retention * 1000,
+				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 = {
 			// 增加了此项
@@ -202,16 +206,16 @@ MQTT.prototype.init = function (config) {
 			url,
 			pubsubCollection: 'ascoltatori',
 			mongo: {}
-		}
+		};
 
 		// 数据持久化参数设置
 		conf.persistence = Object.assign({
 			factory: mosca.persistence.Mongo,
 			ttl: {
 				// TTL for subscriptions
-				subscriptions: cg.message_retention * 1000,
+				subscriptions: cg.message_retention * 1000, // 恢复为毫秒
 				// TTL for packets
-				packets: cg.message_retention * 1000,
+				packets: cg.message_retention * 1000, // 恢复为毫秒
 			}
 		}, conf.backend);
 	}
@@ -285,7 +289,9 @@ MQTT.prototype.main = function (state) {
 	 * 身份验证
 	 */
 	sr.authenticate = (client, username, password, callback) => {
-		$.log.info("收到身份验证", username, password);
+		// 正确获取客户端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 {
@@ -310,7 +316,6 @@ MQTT.prototype.main = function (state) {
 		return true;
 	};
 
-
 	/**
 	 * 验证订阅，决定客户端可以订阅哪些主题
 	 */
@@ -347,9 +352,9 @@ MQTT.prototype.subscribed = function (topic, client) {
 };
 
 /**
- * 客户端断开连接时的处理
- * @param {Object} client 客户端对象
- */
+	 * 客户端断开连接时的处理
+	 * @param {Object} client 客户端对象
+	 */
 MQTT.prototype.clientDisconnected = function (client) {
 	const clientId = client.id;
 	const now = Date.now();
@@ -357,8 +362,8 @@ MQTT.prototype.clientDisconnected = function (client) {
 	$.log.info(`MQTT客户端 ${clientId} 断开连接`);
 
 	// 更新客户端断开连接时间
-	if (this.clientHistory[clientId]) {
-		this.clientHistory[clientId].disconnectTime = now;
+	if (this.securityRecords.client[clientId]) {
+		this.securityRecords.client[clientId].disconnectTime = now;
 	}
 };
 
@@ -372,12 +377,12 @@ MQTT.prototype.published = function (packet, client) {
 };
 
 /**
- * 身份验证 - 主要入口函数
- * @param {Object} client 客户端
- * @param {String} username 用户名
- * @param {String} password 密码
- * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
- */
+	 * 身份验证 - 主要入口函数
+	 * @param {Object} client 客户端
+	 * @param {String} username 用户名
+	 * @param {String} password 密码
+	 * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
+	 */
 MQTT.prototype.auth = async function (client, username, password, callback) {
 	try {
 		// 检查客户端状态（拉黑、异常重连等）- 现在是异步操作
@@ -397,6 +402,13 @@ MQTT.prototype.auth = async function (client, username, password, callback) {
 			return;
 		}
 
+		// 检查密码错误次数限制（防暴力破解）
+		const passwordLimitResult = await this.checkPasswordAttemptLimit(client, username);
+		if (passwordLimitResult === false) {
+			callback(null, false);
+			return;
+		}
+
 		// 查询用户密码并验证（异步操作，需要callback）
 		this.checkAccount(client, username, passwordStr, callback);
 	} catch (error) {
@@ -421,7 +433,8 @@ MQTT.prototype.checkClientStatus = async function (client) {
 
 		// 检测是否有异常重连行为
 		// 注意：detectReconnectAbuse内部也有黑名单相关操作，后续可以考虑重构为使用异步函数
-		if (this.detectReconnectAbuse(client)) {
+		const hasReconnectAbuse = await this.detectReconnectAbuse(client);
+		if (hasReconnectAbuse) {
 			$.log.warn(`拒绝客户端 ${client.id} 身份验证：检测到异常重连行为`);
 			return false;
 		}
@@ -461,58 +474,68 @@ MQTT.prototype.validateCredentials = function (client, username, passwordStr) {
  * 查询用户密码并验证
  * @param {Object} client 客户端
  * @param {String} username 用户名
- * @param {String} passwordStr 密码字符串
+ * @param {String} password 密码字符串
  * @param {Function} callback 回调函数
  */
-MQTT.prototype.checkAccount = function (client, username, passwordStr, callback) {
+MQTT.prototype.checkAccount = async function (client, username, password, callback) {
+	if (!username || !password) {
+		return;
+	}
 	var sql = $.mysql_admin('sys');
 	try {
-		var db = sql.db();
-		db.table = this.config.table_name || 'face_device';
+		var dbs = sql.db();
 		// 先尝试通过客户端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;
+
+		// 判断设备连接
+		var db1 = dbs.new(this.config.table_name || 'face_device', "");
+		var obj = await db1.getObj({
+			username,
+			clientid: client.id
 		});
-	} catch (error) {
-		$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, error);
-		callback(null, false);
-		return;
+		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}`);
+				}
+			}
+		}
 	}
-};
-
-/**
-	 * 验证密码
-	 * @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}`);
+	catch (err) {
+		$.log.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
 	}
-
-	callback(null, isMatch);
-};
+	callback(null, false);
+}
 
 /**
  * 验证发布，决定客户端可以发布哪些主题
@@ -623,8 +646,8 @@ MQTT.prototype.checkHighFrequency = async function (client) {
 			lastReset: now
 		};
 	} else {
-		// 检查是否需要重置计数器
-		if (now - this.messageCounters[clientId].lastReset > config.time_window) {
+		// 检查是否需要重置计数器（注意：time_window现在是秒，需要转换为毫秒进行比较）
+		if (now - this.messageCounters[clientId].lastReset > config.time_window * 1000) {
 			this.messageCounters[clientId].count = 1;
 			this.messageCounters[clientId].lastReset = now;
 		} else {
@@ -637,7 +660,7 @@ MQTT.prototype.checkHighFrequency = async function (client) {
 	if (this.messageCounters[clientId].count > config.max_messages) {
 		// 拉黑客户端 - 使用新的异步函数
 		try {
-			await this.addClientToBlacklist(clientId, config.block_duration);
+			await this.addBlacklist(clientId, config.block_duration);
 		} catch (error) {
 			$.log.error(`拉黑高频请求客户端 ${clientId} 时出错:`, error);
 		}
@@ -659,7 +682,7 @@ MQTT.prototype.blockClient = async function (client) {
 
 	try {
 		// 使用新的异步函数添加到黑名单
-		await this.addClientToBlacklist(clientId, config.block_duration);
+		await this.addBlacklist(clientId, config.block_duration);
 	} catch (error) {
 		$.log.error(`拉黑MQTT客户端 ${clientId} 时出错:`, error);
 	}
@@ -683,80 +706,80 @@ MQTT.prototype.detectReconnectAbuse = async function (client) {
 	try {
 		const clientId = client.id;
 		const now = Date.now();
-		const config = this.config.reconnect_detection;
+		const config = this.config;
 
-		// 从client对象中获取IP（这里可能需要根据实际情况调整获取IP的方式）
-		const clientIp = client.connection.stream.remoteAddress || 'unknown';
+			// 从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;
-		}
+			// 检查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;
-		}
+			// 检查是否是首次连接
+			if (!this.securityRecords.client[clientId]) {
+				// 首次连接，初始化连接历史
+				this.securityRecords.client[clientId] = {
+					ip: clientIp,
+					connectCount: 1,
+					lastConnectTime: now,
+					disconnectTime: null,
+					reconnectAttempts: 0
+				};
+				return false;
+			}
 
-		// 获取客户端历史记录
-		const history = this.clientHistory[clientId];
+			// 获取客户端历史记录
+			const history = this.securityRecords.client[clientId];
 
-		// 检查是否是来自不同IP的连接
-		if (history.ip !== clientIp) {
-			$.log.warn(`检测到客户端ID ${clientId} 从不同IP连接: 原IP ${history.ip}, 新IP ${clientIp}`);
+			// 检查是否是来自不同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的连接行为
+				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);
+				// 禁止新IP连接
+				try {
+					await this.addIpToBanlist(clientIp, config.reconnect_ip_duration);
+				} catch (error) {
+					$.log.error(`禁止IP ${clientIp} 时出错:`, error);
+				}
+				return true;
 			}
-			return true;
-		}
 
-		// 检查是否在短时间内频繁重连
-		const timeSinceLastConnect = now - history.lastConnectTime;
+			// 检查是否在短时间内频繁重连
+			const timeSinceLastConnect = now - history.lastConnectTime;
 
-		// 如果两次连接间隔很短，增加重连尝试计数
-		if (timeSinceLastConnect < config.frequent_reconnect_threshold) {
-			history.reconnectAttempts++;
-		} else {
-			// 重置重连计数
-			history.reconnectAttempts = 0;
-		}
+			// 如果两次连接间隔很短，增加重连尝试计数
+			if (timeSinceLastConnect < config.reconnect_frequency_threshold * 1000) {
+				history.reconnectAttempts++;
+			} else {
+				// 重置重连计数
+				history.reconnectAttempts = 0;
+			}
 
-		// 更新连接计数和时间
-		history.connectCount++;
-		history.lastConnectTime = now;
+			// 更新连接计数和时间
+				history.connectCount++;
+				history.lastConnectTime = now;
 
-		// 检查是否超过最大重连尝试次数
-		if (history.reconnectAttempts > config.max_reconnect_attempts) {
-			$.log.warn(`客户端 ${clientId} 重连过于频繁，已尝试 ${history.reconnectAttempts} 次重连`);
+			// 检查是否超过最大重连尝试次数
+			if (history.reconnectAttempts > config.max_attempts) {
+				$.log.warn(`客户端 ${clientId} 重连过于频繁，已尝试 ${history.reconnectAttempts} 次重连`);
 
-			// 禁止该客户端ID重连 - 使用新的异步函数
-			try {
-				await this.addClientToBlacklist(clientId, config.client_id_ban_duration);
-			} catch (error) {
-				$.log.error(`禁止频繁重连客户端 ${clientId} 时出错:`, error);
+				// 禁止该客户端ID重连
+				try {
+					await this.addBlacklist(clientId, config.reconnect_client_duration);
+				} catch (error) {
+					$.log.error(`禁止频繁重连客户端 ${clientId} 时出错:`, error);
+				}
+				return true;
 			}
-			return true;
-		}
 
 		// 正常连接
 		return false;
@@ -767,6 +790,96 @@ MQTT.prototype.detectReconnectAbuse = async function (client) {
 	}
 };
 
+/**
+ * 异步检查密码尝试次数限制
+ * @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 状态
@@ -823,9 +936,9 @@ MQTT.prototype.isClientBlocked = async function (clientId) {
  * @param {Number} duration 拉黑时长（毫秒）
  * @returns {Promise<Boolean>} true表示添加成功，false表示添加失败
  */
-MQTT.prototype.addClientToBlacklist = async function (clientId, duration) {
+MQTT.prototype.addBlacklist = async function (clientId, duration) {
 	const now = Date.now();
-	const unblockTime = now + (duration || this.config.rate_limit.block_duration);
+	const unblockTime = now + (duration || this.config.rate_limit.block_duration) * 1000; // 转换为毫秒
 
 	try {
 		// 根据存储类型选择不同的实现方式
@@ -839,7 +952,7 @@ MQTT.prototype.addClientToBlacklist = async function (clientId, duration) {
 			this.blockedClients[clientId] = unblockTime;
 		}
 
-		$.log.warn(`MQTT客户端 ${clientId} 被添加到黑名单，限制时长: ${duration / 3600000}小时`);
+		$.log.warn(`MQTT客户端 ${clientId} 被添加到黑名单，限制时长: ${(duration || this.config.rate_limit.block_duration) / 3600}小时`);
 		return true;
 	} catch (error) {
 		$.log.error(`添加客户端 ${clientId} 到黑名单时出错:`, error);
@@ -895,7 +1008,7 @@ MQTT.prototype.isIpBanned = async function (ip) {
  */
 MQTT.prototype.addIpToBanlist = async function (ip, duration) {
 	const now = Date.now();
-	const unbanTime = now + (duration || this.config.reconnect_detection.ip_ban_duration);
+	const unbanTime = now + (duration || this.config.reconnect_ip_duration) * 1000; // 转换为毫秒
 
 	try {
 		// 根据存储类型选择不同的实现方式
@@ -909,7 +1022,7 @@ MQTT.prototype.addIpToBanlist = async function (ip, duration) {
 			this.bannedIps[ip] = unbanTime;
 		}
 
-		$.log.warn(`IP ${ip} 被添加到禁止列表，限制时长: ${duration / 3600000}小时`);
+		$.log.warn(`IP ${ip} 被添加到禁止列表，限制时长: ${(duration || this.config.reconnect_ip_duration) / 3600}小时`);
 		return true;
 	} catch (error) {
 		$.log.error(`添加IP ${ip} 到禁止列表时出错:`, error);
@@ -917,4 +1030,78 @@ MQTT.prototype.addIpToBanlist = async function (ip, duration) {
 	}
 };
 
+/**
+ * 异步从黑名单中移出客户端
+ * @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;