perf: 优化Parse.go的代码，添加注释，规范输出

Common/Parse.go

@@ -19,143 +19,211 @@ func Parse(Info *Config.HostInfo) {
 	ParseScantype(Info)
 }
 
-func ParseUser() {
+// ParseUser 解析用户名配置,支持直接指定用户名列表或从文件读取
+func ParseUser() error {
+	// 如果未指定用户名和用户名文件,直接返回
 	if Username == "" && Userfile == "" {
-		return
+		return nil
-	}
-	var Usernames []string
-	if Username != "" {
-		Usernames = strings.Split(Username, ",")
 	}
 
+	var usernames []string
+
+	// 处理直接指定的用户名列表
+	if Username != "" {
+		usernames = strings.Split(Username, ",")
+		fmt.Printf("[*] 已加载直接指定的用户名: %d 个\n", len(usernames))
+	}
+
+	// 从文件加载用户名列表
 	if Userfile != "" {
 		users, err := Readfile(Userfile)
-		if err == nil {
+		if err != nil {
+			return fmt.Errorf("读取用户名文件失败: %v", err)
+		}
+
+		// 过滤空用户名
 		for _, user := range users {
 			if user != "" {
-					Usernames = append(Usernames, user)
+				usernames = append(usernames, user)
-				}
 			}
 		}
+		fmt.Printf("[*] 已从文件加载用户名: %d 个\n", len(users))
 	}
 
-	Usernames = RemoveDuplicate(Usernames)
+	// 去重处理
+	usernames = RemoveDuplicate(usernames)
+	fmt.Printf("[*] 去重后用户名总数: %d 个\n", len(usernames))
+
+	// 更新用户字典
 	for name := range Userdict {
-		Userdict[name] = Usernames
+		Userdict[name] = usernames
-	}
 	}
 
-func ParsePass(Info *Config.HostInfo) {
+	return nil
-	var PwdList []string
+}
+
+// ParsePass 解析密码、哈希值、URL和端口配置
+func ParsePass(Info *Config.HostInfo) error {
+	// 处理直接指定的密码列表
+	var pwdList []string
 	if Password != "" {
-		passs := strings.Split(Password, ",")
+		passes := strings.Split(Password, ",")
-		for _, pass := range passs {
+		for _, pass := range passes {
 			if pass != "" {
-				PwdList = append(PwdList, pass)
+				pwdList = append(pwdList, pass)
 			}
 		}
-		Passwords = PwdList
+		Passwords = pwdList
+		fmt.Printf("[*] 已加载直接指定的密码: %d 个\n", len(pwdList))
 	}
+
+	// 从文件加载密码列表
 	if Passfile != "" {
-		passs, err := Readfile(Passfile)
+		passes, err := Readfile(Passfile)
-		if err == nil {
+		if err != nil {
-			for _, pass := range passs {
+			return fmt.Errorf("读取密码文件失败: %v", err)
+		}
+		for _, pass := range passes {
 			if pass != "" {
-					PwdList = append(PwdList, pass)
+				pwdList = append(pwdList, pass)
 			}
 		}
-			Passwords = PwdList
+		Passwords = pwdList
-		}
+		fmt.Printf("[*] 已从文件加载密码: %d 个\n", len(passes))
 	}
+
+	// 处理哈希文件
 	if Hashfile != "" {
-		hashs, err := Readfile(Hashfile)
+		hashes, err := Readfile(Hashfile)
-		if err == nil {
+		if err != nil {
-			for _, line := range hashs {
+			return fmt.Errorf("读取哈希文件失败: %v", err)
+		}
+
+		validCount := 0
+		for _, line := range hashes {
 			if line == "" {
 				continue
 			}
 			if len(line) == 32 {
 				Hashs = append(Hashs, line)
+				validCount++
 			} else {
-					fmt.Println("[-] len(hash) != 32 " + line)
+				fmt.Printf("[!] 无效的哈希值(长度!=32): %s\n", line)
-				}
-			}
-		}
-	}
-	if URL != "" {
-		urls := strings.Split(URL, ",")
-		TmpUrls := make(map[string]struct{})
-		for _, url := range urls {
-			if _, ok := TmpUrls[url]; !ok {
-				TmpUrls[url] = struct{}{}
-				if url != "" {
-					Urls = append(Urls, url)
-				}
-			}
-		}
-	}
-	if UrlFile != "" {
-		urls, err := Readfile(UrlFile)
-		if err == nil {
-			TmpUrls := make(map[string]struct{})
-			for _, url := range urls {
-				if _, ok := TmpUrls[url]; !ok {
-					TmpUrls[url] = struct{}{}
-					if url != "" {
-						Urls = append(Urls, url)
-					}
-				}
-			}
-		}
-	}
-	if PortFile != "" {
-		ports, err := Readfile(PortFile)
-		if err == nil {
-			newport := ""
-			for _, port := range ports {
-				if port != "" {
-					newport += port + ","
-				}
-			}
-			Ports = newport
 			}
 		}
+		fmt.Printf("[*] 已加载有效哈希值: %d 个\n", validCount)
 	}
 
+	// 处理直接指定的URL列表
+	if URL != "" {
+		urls := strings.Split(URL, ",")
+		tmpUrls := make(map[string]struct{})
+		for _, url := range urls {
+			if url != "" {
+				if _, ok := tmpUrls[url]; !ok {
+					tmpUrls[url] = struct{}{}
+					Urls = append(Urls, url)
+				}
+			}
+		}
+		fmt.Printf("[*] 已加载直接指定的URL: %d 个\n", len(Urls))
+	}
+
+	// 从文件加载URL列表
+	if UrlFile != "" {
+		urls, err := Readfile(UrlFile)
+		if err != nil {
+			return fmt.Errorf("读取URL文件失败: %v", err)
+		}
+
+		tmpUrls := make(map[string]struct{})
+		for _, url := range urls {
+			if url != "" {
+				if _, ok := tmpUrls[url]; !ok {
+					tmpUrls[url] = struct{}{}
+					Urls = append(Urls, url)
+				}
+			}
+		}
+		fmt.Printf("[*] 已从文件加载URL: %d 个\n", len(urls))
+	}
+
+	// 从文件加载端口列表
+	if PortFile != "" {
+		ports, err := Readfile(PortFile)
+		if err != nil {
+			return fmt.Errorf("读取端口文件失败: %v", err)
+		}
+
+		var newport strings.Builder
+		for _, port := range ports {
+			if port != "" {
+				newport.WriteString(port)
+				newport.WriteString(",")
+			}
+		}
+		Ports = newport.String()
+		fmt.Printf("[*] 已从文件加载端口配置\n")
+	}
+
+	return nil
+}
+
+// Readfile 读取文件内容并返回非空行的切片
 func Readfile(filename string) ([]string, error) {
+	// 打开文件
 	file, err := os.Open(filename)
 	if err != nil {
-		fmt.Printf("Open %s error, %v\n", filename, err)
+		fmt.Printf("[!] 打开文件 %s 失败: %v\n", filename, err)
-		os.Exit(0)
+		return nil, err
 	}
 	defer file.Close()
+
 	var content []string
 	scanner := bufio.NewScanner(file)
 	scanner.Split(bufio.ScanLines)
+
+	// 逐行读取文件内容
+	lineCount := 0
 	for scanner.Scan() {
 		text := strings.TrimSpace(scanner.Text())
 		if text != "" {
-			content = append(content, scanner.Text())
+			content = append(content, text)
+			lineCount++
 		}
 	}
+
+	// 检查扫描过程中是否有错误
+	if err := scanner.Err(); err != nil {
+		fmt.Printf("[!] 读取文件 %s 时出错: %v\n", filename, err)
+		return nil, err
+	}
+
+	fmt.Printf("[*] 成功读取文件 %s: %d 行\n", filename, lineCount)
 	return content, nil
 }
 
-func ParseInput(Info *Config.HostInfo) {
+// ParseInput 解析和验证输入参数配置
+func ParseInput(Info *Config.HostInfo) error {
+	// 检查必要的目标参数
 	if Info.Host == "" && HostFile == "" && URL == "" && UrlFile == "" {
-		fmt.Println("Host is none")
+		fmt.Println("[!] 未指定扫描目标")
 		flag.Usage()
-		os.Exit(0)
+		return fmt.Errorf("必须指定扫描目标")
 	}
 
+	// 配置基本参数
 	if BruteThread <= 0 {
 		BruteThread = 1
+		fmt.Printf("[*] 已将暴力破解线程数设置为: %d\n", BruteThread)
 	}
 
-	if TmpSave == true {
+	if TmpSave {
 		IsSave = false
+		fmt.Println("[*] 已启用临时保存模式")
 	}
 
+	// 处理端口配置
 	if Ports == DefaultPorts {
 		Ports += "," + Webport
 	}
@@ -166,74 +234,90 @@ func ParseInput(Info *Config.HostInfo) {
 		} else {
 			Ports += "," + PortAdd
 		}
+		fmt.Printf("[*] 已添加额外端口: %s\n", PortAdd)
 	}
 
+	// 处理用户名配置
 	if UserAdd != "" {
-		user := strings.Split(UserAdd, ",")
+		users := strings.Split(UserAdd, ",")
-		for a := range Userdict {
+		for dict := range Userdict {
-			Userdict[a] = append(Userdict[a], user...)
+			Userdict[dict] = append(Userdict[dict], users...)
-			Userdict[a] = RemoveDuplicate(Userdict[a])
+			Userdict[dict] = RemoveDuplicate(Userdict[dict])
 		}
+		fmt.Printf("[*] 已添加额外用户名: %s\n", UserAdd)
 	}
 
+	// 处理密码配置
 	if PassAdd != "" {
-		pass := strings.Split(PassAdd, ",")
+		passes := strings.Split(PassAdd, ",")
-		Passwords = append(Passwords, pass...)
+		Passwords = append(Passwords, passes...)
 		Passwords = RemoveDuplicate(Passwords)
+		fmt.Printf("[*] 已添加额外密码: %s\n", PassAdd)
 	}
-	if Socks5Proxy != "" && !strings.HasPrefix(Socks5Proxy, "socks5://") {
+
+	// 处理Socks5代理配置
+	if Socks5Proxy != "" {
+		if !strings.HasPrefix(Socks5Proxy, "socks5://") {
 			if !strings.Contains(Socks5Proxy, ":") {
 				Socks5Proxy = "socks5://127.0.0.1" + Socks5Proxy
 			} else {
 				Socks5Proxy = "socks5://" + Socks5Proxy
 			}
 		}
-	if Socks5Proxy != "" {
+
-		fmt.Println("Socks5Proxy:", Socks5Proxy)
 		_, err := url.Parse(Socks5Proxy)
 		if err != nil {
-			fmt.Println("Socks5Proxy parse error:", err)
+			return fmt.Errorf("Socks5代理格式错误: %v", err)
-			os.Exit(0)
 		}
 		NoPing = true
+		fmt.Printf("[*] 使用Socks5代理: %s\n", Socks5Proxy)
 	}
+
+	// 处理HTTP代理配置
 	if Proxy != "" {
-		if Proxy == "1" {
+		switch Proxy {
+		case "1":
 			Proxy = "http://127.0.0.1:8080"
-		} else if Proxy == "2" {
+		case "2":
 			Proxy = "socks5://127.0.0.1:1080"
-		} else if !strings.Contains(Proxy, "://") {
+		default:
+			if !strings.Contains(Proxy, "://") {
 				Proxy = "http://127.0.0.1:" + Proxy
 			}
-		fmt.Println("Proxy:", Proxy)
-		if !strings.HasPrefix(Proxy, "socks") && !strings.HasPrefix(Proxy, "http") {
-			fmt.Println("no support this proxy")
-			os.Exit(0)
-		}
-		_, err := url.Parse(Proxy)
-		if err != nil {
-			fmt.Println("Proxy parse error:", err)
-			os.Exit(0)
-		}
 		}
 
-	if Hash != "" && len(Hash) != 32 {
+		if !strings.HasPrefix(Proxy, "socks") && !strings.HasPrefix(Proxy, "http") {
-		fmt.Println("[-] Hash is error,len(hash) must be 32")
+			return fmt.Errorf("不支持的代理类型")
-		os.Exit(0)
+		}
-	} else {
+
+		_, err := url.Parse(Proxy)
+		if err != nil {
+			return fmt.Errorf("代理格式错误: %v", err)
+		}
+		fmt.Printf("[*] 使用代理: %s\n", Proxy)
+	}
+
+	// 处理Hash配置
+	if Hash != "" {
+		if len(Hash) != 32 {
+			return fmt.Errorf("Hash长度必须为32位")
+		}
 		Hashs = append(Hashs, Hash)
 	}
+
+	// 处理Hash列表
 	Hashs = RemoveDuplicate(Hashs)
 	for _, hash := range Hashs {
-		hashbyte, err := hex.DecodeString(Hash)
+		hashByte, err := hex.DecodeString(hash)
 		if err != nil {
-			fmt.Println("[-] Hash is error,hex decode error ", hash)
+			fmt.Printf("[!] Hash解码失败: %s\n", hash)
 			continue
-		} else {
-			HashBytes = append(HashBytes, hashbyte)
 		}
+		HashBytes = append(HashBytes, hashByte)
 	}
 	Hashs = []string{}
+
+	return nil
 }
 
 // ParseScantype 解析扫描类型并设置对应的端口