admin/fscan
1
0
Fork 0
mirror of https://github.com/shadow1ng/fscan.git synced 2025-11-05 10:45:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
ZacharyZcR 2024-12-18 22:06:38 +08:00
parent 5d9bcaaadc
commit 0eeda0879d
1 changed files with 192 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

300
Common/Parse.go
View File

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