refactor: 输出格式重构，去掉所有插件的多线程，因为多线程会导致结果不准确，加入进度条

Plugins/Postgres.go

@@ -6,7 +6,6 @@ import (
 	_ "github.com/lib/pq"
 	"github.com/shadow1ng/fscan/Common"
 	"strings"
-	"sync"
 	"time"
 )
 
@@ -17,107 +16,62 @@ func PostgresScan(info *Common.HostInfo) (tmperr error) {
 	}
 
 	maxRetries := Common.MaxRetries
-	threads := Common.BruteThreads
+	starttime := time.Now().Unix()
 
-	// 创建任务通道
-	taskChan := make(chan struct {
-		user string
-		pass string
-	}, len(Common.Userdict["postgresql"])*len(Common.Passwords))
-
-	resultChan := make(chan error, threads)
-
-	// 生成所有用户名密码组合任务
+	// 遍历所有用户名密码组合
 	for _, user := range Common.Userdict["postgresql"] {
 		for _, pass := range Common.Passwords {
 			pass = strings.Replace(pass, "{user}", user, -1)
-			taskChan <- struct {
-				user string
-				pass string
-			}{user, pass}
-		}
-	}
-	close(taskChan)
 
-	// 启动工作线程
-	var wg sync.WaitGroup
-	for i := 0; i < threads; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			starttime := time.Now().Unix()
+			// 检查是否超时
+			if time.Now().Unix()-starttime > int64(Common.Timeout) {
+				return fmt.Errorf("扫描超时")
+			}
 
-			for task := range taskChan {
-				// 重试循环
-				for retryCount := 0; retryCount < maxRetries; retryCount++ {
-					// 检查是否超时
-					if time.Now().Unix()-starttime > int64(Common.Timeout) {
-						resultChan <- fmt.Errorf("扫描超时")
-						return
-					}
+			// 重试循环
+			for retryCount := 0; retryCount < maxRetries; retryCount++ {
+				// 执行PostgreSQL连接
+				done := make(chan struct {
+					success bool
+					err     error
+				})
 
-					// 执行PostgreSQL连接
-					done := make(chan struct {
+				go func(user, pass string) {
+					success, err := PostgresConn(info, user, pass)
+					done <- struct {
 						success bool
 						err     error
-					})
+					}{success, err}
+				}(user, pass)
 
-					go func(user, pass string) {
-						success, err := PostgresConn(info, user, pass)
-						done <- struct {
-							success bool
-							err     error
-						}{success, err}
-					}(task.user, task.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("连接超时")
+				// 等待结果或超时
+				var err error
+				select {
+				case result := <-done:
+					err = result.err
+					if result.success && err == nil {
+						return nil
 					}
-
-					// 处理错误情况
-					if err != nil {
-						errlog := fmt.Sprintf("PostgreSQL %v:%v %v %v %v",
-							info.Host, info.Ports, task.user, task.pass, err)
-						Common.LogError(errlog)
-
-						// 检查是否需要重试
-						if retryErr := Common.CheckErrs(err); retryErr != nil {
-							if retryCount == maxRetries-1 {
-								resultChan <- err
-								return
-							}
-							continue // 继续重试
-						}
-					}
-
-					break // 如果不需要重试，跳出重试循环
+				case <-time.After(time.Duration(Common.Timeout) * time.Second):
+					err = fmt.Errorf("连接超时")
 				}
-			}
-			resultChan <- nil
-		}()
-	}
 
-	// 等待所有线程完成
-	go func() {
-		wg.Wait()
-		close(resultChan)
-	}()
+				// 处理错误情况
+				if err != nil {
+					errlog := fmt.Sprintf("PostgreSQL %v:%v %v %v %v",
+						info.Host, info.Ports, user, pass, err)
+					Common.LogError(errlog)
 
-	// 检查结果
-	for err := range resultChan {
-		if err != nil {
-			tmperr = err
-			if retryErr := Common.CheckErrs(err); retryErr != nil {
-				return err
+					// 检查是否需要重试
+					if retryErr := Common.CheckErrs(err); retryErr != nil {
+						if retryCount == maxRetries-1 {
+							return err
+						}
+						continue // 继续重试
+					}
+				}
+
+				break // 如果不需要重试，跳出重试循环
 			}
 		}
 	}