v2.1.2 核心优化与多架构发布 (#561)

* feat: v2.1.0 核心重构与功能增强

## 架构重构
- 全局变量消除，迁移至 Config/State 对象
- SMB 插件融合（smb/smb2/smbghost/smbinfo）
- 服务探测重构，实现 Nmap 风格 fallback 机制
- 输出系统重构，TXT 实时刷盘 + 双写机制
- i18n 框架升级至 go-i18n

## 性能优化
- 正则表达式预编译
- 内存优化 map[string]struct{}
- 并发指纹匹配
- SOCKS5 连接复用
- 滑动窗口调度 + 自适应线程池

## 新功能
- Web 管理界面
- 多格式 POC 适配（xray/afrog）
- 增强指纹库（3139条）
- Favicon hash 指纹识别
- 插件选择性编译（Build Tags）
- fscan-lab 靶场环境
- 默认端口扩展（62→133）

## 构建系统
- 添加 no_local tag 支持排除本地插件
- 多版本构建：fscan/fscan-nolocal/fscan-web
- CI 添加 snapshot 模式支持仅测试构建

## Bug 修复
- 修复 120+ 个问题，包括 RDP panic、批量扫描漏报、
  JSON 输出格式、Redis 检测、Context 超时等

## 测试增强
- 单元测试覆盖率 74-100%
- 并发安全测试
- 集成测试（Web/端口/服务/SSH/ICMP）

* fix(ci): 移除 PR 对 Project 自动化的触发

* fix: Elasticsearch未授权检测优先于爆破 (#554)

* fix: 修复RDP爆破高误报率问题 (#555)

- 移除 screen.go 中错误的认证结果覆盖逻辑
- 启用 NLA 协议的 ErrorCode 字段检测
- 添加 PubKeyAuth 验证确保认证真正成功
- 修复 io.go 中错误被静默忽略的问题
- 修复 socket.go/io.go 中可能导致 panic 的代码
- 修复 screen.go 中文件句柄泄漏和 log.Panic

* fix: 修复-user/-pwd凭据参数不生效的问题

问题原因：
- Parse()解析凭据后更新globalConfig
- 但BuildConfigFromFlags()创建新Config时使用默认字典
- 导致解析的UserPassPairs等凭据信息被丢弃

修复内容：
1. initialize.go: 将Parse解析的凭据结果应用到新Config
2. credential.go: 单用户密码对时创建UserPassPairs
3. rdp.go: 单凭据测试时跳过指纹识别，减少连接次数

* feat: RDP使用NLA仅验证模式，避免挤掉已登录用户

- 添加ErrNLAAuthSuccess标志用于NLA验证成功信号
- tpkt层支持nlaAuthOnly模式，验证成功后不建立完整会话
- x224层正确传播NLA验证结果
- rdpCrack改用NlaAuth进行凭据验证

* fix: 修复进度条在Windows终端满屏重复输出的问题

- 添加终端宽度检测，动态调整进度条长度
- 使用空格覆盖清除旧内容，避免残留
- 简化进度条格式，确保不超过终端宽度

* feat: 优化日志颜色方案，区分漏洞和普通信息

- 新增 LogVuln 级别（红色），用于漏洞和重要发现
- 密码爆破成功、未授权访问、POC漏洞等改用红色显示
- 普通信息（扫描统计等）改为白色
- Web指纹保持绿色

* refactor: 精简化输出，移除冗余启动信息

- 移除showParseSummary开局配置输出
- 移除LogPluginInfo/LogPluginInfoWithPort插件信息输出
- 移除alive_scanner冗余统计输出
- 移除port_scan_start扫描开始提示
- 移除handleUDPPorts SNMP死代码
- 移除相关i18n条目

* chore: 版本号更新为2.1.1

* fix: 降级依赖版本以保持Go 1.20兼容性

* feat(ldap): 添加NTLM Hash认证支持 (#433)

* chore: 清理无用的 replace 指令

* fix(ping): 修复 TTL expired 导致主机误判为存活的问题

在 ExecCommandPing 中增加错误关键词检测，当 ping 输出包含
TTL expired、Destination unreachable 等错误信息时，不再将
目标主机标记为存活。

Fixes #454

* fix(proxy): 修复透明代理导致输出全端口的问题

在代理初始化时主动探测代理行为，通过连接 RFC 5737 保留的
测试地址来检测是否存在"全回显"问题。如果探测到代理不可靠，
则在端口扫描时跳过所有端口，避免误报。

- 新增 proxyReliable 标志位标记代理可靠性
- 新增 ProbeProxyBehavior 函数探测代理行为
- 端口扫描前检查代理可靠性并输出警告

Fixes #495

* refactor: 移动debug模块到common/debug子包

* fix(web): 修复-u模式下Web插件未执行的问题

* fix: 优化输出格式和颜色显示

- 网段统计格式改为 10.253.0.0/16 网段存活: 26
- WebTitle基础信息改为白色，指纹识别单独绿色输出
- 移除重复的端口数量输出

* fix: URL解析自动补全协议头

-uf 文件中 192.168.1.1:8080 自动转为 http://192.168.1.1:8080

* fix: 修复-u/-uf模式下URLs丢失导致0目标扫描的问题

Parse阶段将URLs设置到全局状态，但Initialize随后创建新状态
并覆盖了全局状态，导致URLs数据丢失。现在在创建新状态前
先保存并迁移Parse阶段设置的URLs和HostPorts数据。

* fix: 智能检测HTTP/HTTPS协议并优化URL显示

- 修复-u/-uf模式URLs丢失导致0目标扫描问题
- detectProtocol改为主动TLS握手检测，不依赖服务名
- WebTitle输出显示完整协议(http/https)
- 隐藏标准端口(80/443)使输出更简洁

* refactor: 精简parsers包，统一配置构建入口

- 删除冗余的中间层（XXXInput、XXXParser类）
- 新增 config_builder.go 统一配置构建
- parsers包从3000+行精简至~540行
- 保留核心函数：ParseIP、ParsePort、文件读取、凭据解析

* test: 扩展parsers单元测试覆盖边缘情况

- 新增内网简写解析测试(192/172/10)
- 新增完整IP范围和无效CIDR测试
- 新增Windows行尾(CRLF)处理测试
- 新增凭据和哈希文件解析测试
- 新增端口解析边缘情况测试
- 测试覆盖率达到94.2%

* refactor: 优化控制台输出格式

- 去掉时间戳，保留[*][+]前缀
- Web输出合并WebTitle和WebFinger为一行
- 有指纹显示绿色[+]，无指纹显示白色[*]
- 格式: code:xxx len:xxx title:xxx server:xxx [指纹]
- 服务探测格式: [Product:xxx ||Version:xxx] Banner:(xxx)
- 字段对齐，输出更清爽

* feat: 添加凭据测试未发现弱密码的提示

- credential_tester.go: 失败时设置 Type=ResultTypeCredential
- scanner.go: 根据结果类型在 error 级别输出'未发现弱密码'提示
- 新增 i18n 翻译 brute_no_weak_pass

使用 -log all 或 -log error 可看到此提示

* refactor(logging): 重构日志级别为层级过滤设计

- LogLevel 从 string 改为 int 类型，支持层级比较
- 层级设计：Debug(0) < Base(1) < Info(2) < Success(3) < Vuln(4) < Error(5)
- 设置一个级别后，显示该级别及以上的日志
- Error 级别始终显示，不会被配置过滤掉
- 保留向后兼容别名（LevelAll, LevelInfoSuccess 等）
- 更新测试以匹配新的层级过滤行为

* style(logging): Error级别日志改为黄色显示

* style(findnet): NetInfo输出改为每行一个IP

* refactor(ms17010): 优化错误提示，明确指出SMBv1不支持等情况

* fix(credential): 修复凭据测试结果不一致的问题

问题原因：
1. 未知错误类型不重试，导致服务端限流时跳过正确密码
2. SSH 错误分类不够准确，某些临时错误未被识别

修复内容：
1. 未知错误改为可重试（可能是临时问题）
2. 增加 SSH 特有的网络错误识别（handshake failed, disconnect 等）

* fix(portfinger): 修复SMB2服务指纹识别和NetInfo输出问题

- 添加SMB2ProgNeg探针支持现代Windows的SMB2协议
- 修复Go regexp对高位字节的UTF-8兼容问题，使用Latin-1转换
- 修复探针失败后连接重建逻辑
- 修复vendor_product字段名不匹配问题
- 修复NetInfo多行输出被其他日志打断的问题

* fix(config): 从默认端口移除9100，避免触发打印机打印 (#517)

* feat(proxy): 增强代理端口扫描的深度验证机制

- 新增4阶段深度验证：Banner读取→探测发送→响应等待→最终判定
- 新增SOCKS5错误码和代理错误文本检测
- 优化ProbeProxyBehavior探测逻辑，发送数据验证连接可达性
- 解决透明代理/全回显代理导致的假阳性问题

* fix(proxy): 修复代理深度验证的若干问题

- detector.go: 修复 AutoConfigureProxy 覆盖探测结果的问题
  只有未探测过时才设置默认 proxyReliable 值

- port_scan.go: 改进深度验证机制
  - 使用带 Host header 的 HTTP GET 请求替代 OPTIONS
  - 延长响应等待超时至 2s 以适配慢速服务器
  - 正确重置连接 deadline 避免影响后续操作

* refactor: 统一 common 包文件命名风格

Flag.go -> flag.go

* refactor(proxy): 删除自定义 contains() 函数，改用标准库

- 用 strings.Contains() 替代手写的 contains()
- 删除过时的注释

* fix(parsers): 修复带横杠域名被误识别为IP范围的问题

如 111-555.sss.com 这类域名因包含 - 被错误解析为 IP 范围，
添加 looksLikeIPRange() 检查，只有 - 前是有效 IP 才走范围解析

* fix(proxy): 修复代理模式下服务识别错误和端口漏扫问题

- port_scan.go: 验证通过后重建干净连接，避免HTTP GET探测污染服务识别
- port_scan.go: 优化验证策略，用轻量CRLF探测替代HTTP GET，超时从2.2s降至0.6s
- manager.go: 修正ProbeProxyBehavior判断逻辑，超时应视为代理正常转发

* fix(pool): 移除线程池预分配，优化大规模扫描内存占用

WithPreAlloc(true) 会预先创建所有 worker goroutine，
在大规模扫描(如 25域名×65535端口)时可能导致内存问题

* refactor(logging): 统一日志前缀，删除废弃的 LogBase

- 删除 LogBase 函数，所有调用迁移到 LogInfo/LogError
- 新增 PrefixDebug ([.]) 前缀，所有日志级别现在都有前缀
- 修复日志输出缩进不一致的问题
- 删除未使用的 PrefixDefault 常量

* perf(icmp): 实现自适应等待算法优化存活检测性能

- 新增 waitAdaptive 函数，监控响应增量实现智能提前结束
- 算法保守原则：最小等待1s + 连续500ms无新响应才提前结束
- 添加100ms检查间隔避免CPU空转
- 保留原有最大等待时间(3s/6s)作为兜底
- 添加完整单元测试覆盖各种场景

优化效果：
- 全部响应：~100ms (原3s)
- 无响应：~1s (原3s)
- 部分响应后稳定：~1.5s (原3s)

* perf(scan): 实现启发式优化提升扫描体验

1. 端口优先级排序：高价值端口(80,443,22,3389等)优先扫描
   - 用户能更快看到有意义的结果
   - 不影响端口喷洒策略

2. TCP 补充探测：ICMP 响应率<10%时自动启用
   - 对未响应主机用 TCP 80/443/22/445 补充探测
   - 解决防火墙过滤 ICMP 导致漏检的问题

* refactor(grdp): 精简RDP库，删除认证检测不需要的代码

- 删除 VNC 协议支持 (protocol/rfb, client/rfb.go)
- 删除完整客户端框架 (client/)
- 删除 RemoteApp 等插件 (plugin/)
- 删除 RLE 图形解压 (core/rle.go)
- 删除绘图指令处理 (pdu/orders.go, pdu/gdi.go)
- 精简 screen.go，移除截图和完整会话功能
- 移除未使用的 RGB 转换函数

grdp 代码从 13,044 行精简至 7,581 行，削减 42%

* refactor(common): 删除死代码，优化代码风格

- 删除未使用的 joinStrings/joinInts 函数
- 删除未使用的 memStats 字段和 getMemoryInfo 方法
- 简化 parsePasswords 中的循环为 append(...) 形式

* refactor(services): 统一数据库插件的DBWrapper

4个数据库插件(MySQL、PostgreSQL、MSSQL、Oracle)都有相同的sql.DB包装代码，
合并为通用的SQLDBWrapper，减少重复。

* refactor(core,grdp): 删除未使用的死代码

- 移除 BaseScanStrategy.LogPluginInfoWithPort 方法（无调用者）
- 移除 mcs.go 中被注释的旧 connect 函数实现

* refactor: 删除 deadcode 检测出的未使用函数

- proxy/detector.go: 删除 IsSOCKS5Standard, IsProxyInitialized
- findnet.go: 删除 NetworkInfo.OneLine, TreeFormat 方法
- port_scan.go: 删除 estimateScanTime 函数
- web_scanner.go: 删除 GetFingerprints 函数
- 清理相关测试代码

* refactor: 删除更多未使用的死代码

- parse.go: 删除 RemoveDuplicate 函数及其测试
- parsers.go: 删除 excludeHosts, removeDuplicates 别名函数
- 更新测试使用真正的函数名

* fix(test): 修复 TestParseIP_InvalidIPRange 测试用例

- 删除不合理的测试用例（无效IP被当作普通主机名处理是设计行为）
- 修复测试逻辑，只在真正通过时输出"正确"

* fix(scan): 移除域名预解析，保留原始域名进行扫描

域名预解析会将域名转换为IP，导致虚拟主机场景下HTTP访问失败
（Host头变成IP而非域名，无法正确路由）

* fix(scan): 修复 -hf 参数无法单独使用的问题

* fix(proxy): 修复透明代理环境下 SOCKS5 代理全端口误报问题

问题：在透明代理(TUN模式)环境下使用 SOCKS5 代理扫描时，
会出现全端口开放的误报，因为代理可靠性检测被透明代理污染。

修复方案（参考 fscanx）：
1. 将探针从 CRLF 改为 HTTP GET，更有效检测真实连接状态
2. 删除 "uncertain" 状态，无响应一律判定为端口关闭
3. 调整超时时间以适应代理链路延迟

Fixes #524

* feat(telnet): 新增 telnetd RCE 命令执行验证，修复未授权访问日志级别

* fix: 修复 i18n.Tr vet 报错、Unicode 测试用例，移除过期域名

- 移除 i18n.Tr 中错误的 fmt.Sprintf fallback，消除 go vet 误报
- 修复 match_engine_test Unicode 测试用例与 Latin-1 转换逻辑不匹配
- README 移除过期的 fscan.club 域名
- 添加 .gitattributes 统一换行符为 LF

* refactor: 统一控制台输出风格，使用统一的日志函数

手动合并 PR #558 的改动，适配重构后的代码路径

* fix(ci): 修复版本注入和CI触发配置

- goreleaser ldflags 指向正确的包路径 common.version/commit/date
- version 改为 var 支持 ldflags 注入，banner 显示 commit 和构建日期
- test-build 触发分支增加 dev-* 通配

* fix(ci): 修复 Windows 产物 .exe.exe 双后缀问题

* feat(ci): 扩展构建架构支持 MIPS/ARM/FreeBSD/Solaris

core/service_probe.go

@@ -0,0 +1,600 @@
+package core
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/shadow1ng/fscan/common"
+	"github.com/shadow1ng/fscan/core/portfinger"
+)
+
+// 默认超时时间常量
+const (
+	defaultTotalWaitMS = 6000 // Nmap 默认等待时间
+	defaultIntensity   = 7    // 默认探测强度 (1-9)
+)
+
+// sslSecondProbes SSL服务二次探测的探针名称
+var sslSecondProbes = []string{"TerminalServerCookie", "TerminalServer"}
+
+// Probe PortFinger探测器类型别名 - 简化引用
+type (
+	Probe = portfinger.Probe
+	// Match PortFinger匹配规则类型别名
+	Match = portfinger.Match
+)
+
+// PortFinger全局访问 - 简化探测器访问
+var (
+	v           = portfinger.GetGlobalVScan()
+	null        = portfinger.GetNullProbe()
+	commonProbe = portfinger.GetCommonProbe()
+	DecodeData  = portfinger.DecodeData
+)
+
+// readBufPool 读取缓冲区对象池，复用 2KB 缓冲区减少 GC 压力
+var readBufPool = sync.Pool{
+	New: func() interface{} {
+		buf := make([]byte, 2*1024)
+		return &buf
+	},
+}
+
+// ServiceInfo 定义服务识别的结果信息
+type ServiceInfo struct {
+	Name    string            // 服务名称,如 http、ssh 等
+	Banner  string            // 服务返回的横幅信息
+	Version string            // 服务版本号
+	Extras  map[string]string // 其他额外信息,如操作系统、产品名等
+}
+
+// Result 定义单次探测的结果
+type Result struct {
+	Service Service           // 识别出的服务信息
+	Banner  string            // 服务横幅
+	Extras  map[string]string // 额外信息
+	Send    []byte            // 发送的探测数据
+	Recv    []byte            // 接收到的响应数据
+}
+
+// Service 定义服务的基本信息
+type Service struct {
+	Name   string            // 服务名称
+	Extras map[string]string // 服务的额外属性
+}
+
+// Info 定义单个端口探测的上下文信息
+type Info struct {
+	Address       string         // 目标IP地址
+	Port          int            // 目标端口
+	Conn          net.Conn       // 网络连接
+	Result        Result         // 探测结果
+	Found         bool           // 是否成功识别服务
+	config        *common.Config // 配置引用
+	readTimeoutMS int            // 当前读取超时时间（毫秒）
+}
+
+// SmartPortInfoScanner 智能服务识别器：保持nmap准确性，优化网络交互
+type SmartPortInfoScanner struct {
+	Address string
+	Port    int
+	Conn    net.Conn
+	Timeout time.Duration
+	info    *Info
+	config  *common.Config // 配置引用
+}
+
+// 预定义的基础探测器已在PortFinger.go中定义，这里不再重复定义
+
+// NewSmartPortInfoScanner 创建智能服务识别器
+func NewSmartPortInfoScanner(addr string, port int, conn net.Conn, timeout time.Duration, config *common.Config) *SmartPortInfoScanner {
+	return &SmartPortInfoScanner{
+		Address: addr,
+		Port:    port,
+		Conn:    conn,
+		Timeout: timeout,
+		config:  config,
+		info: &Info{
+			Address: addr,
+			Port:    port,
+			Conn:    conn,
+			config:  config,
+			Result: Result{
+				Service: Service{},
+			},
+		},
+	}
+}
+
+// Close 关闭Scanner持有的连接（包括探测过程中可能创建的新连接）
+func (s *SmartPortInfoScanner) Close() {
+	if s.info != nil && s.info.Conn != nil {
+		_ = s.info.Conn.Close()
+		s.info.Conn = nil
+	}
+}
+
+// SmartIdentify 智能服务识别：Banner优先 + 优化的探测策略
+// 返回值: (服务信息, 错误)
+// 注意：TCP连接成功后，端口必然开放，不应该再改变这个判断
+func (s *SmartPortInfoScanner) SmartIdentify() (*ServiceInfo, error) {
+	// 第一阶段：读取初始Banner（大部分服务会主动发送）
+	_, _ = s.tryInitialBanner()
+
+	// 如果初始Banner已识别，返回结果
+	if s.info.Found {
+		serviceInfo := s.buildServiceInfo()
+		// SSL 多阶段探测
+		serviceInfo = s.performSSLSecondStage(serviceInfo)
+		return serviceInfo, nil
+	}
+
+	// 第二阶段：智能探测策略（减少探测器数量）
+	s.smartProbeStrategy()
+
+	// 构造返回结果
+	serviceInfo := s.buildServiceInfo()
+
+	// SSL 多阶段探测（对所有服务进行检查）
+	serviceInfo = s.performSSLSecondStage(serviceInfo)
+
+	return serviceInfo, nil
+}
+
+// tryInitialBanner 尝试读取服务主动发送的Banner
+// 返回值: (响应数据, 错误)
+func (s *SmartPortInfoScanner) tryInitialBanner() ([]byte, error) {
+	// 读取初始响应
+	response, err := s.info.Read()
+	if err != nil {
+		return nil, err
+	}
+
+	if len(response) > 0 {
+		// 使用原有的nmap指纹库解析Banner，保持准确性
+		_ = s.info.tryProbes(response, []*Probe{null, commonProbe})
+	}
+
+	return response, nil
+}
+
+
+// smartProbeStrategy 智能探测策略
+// 改进版：使用 nmap-service-probes.txt 中的 ports 字段和 rarity 排序
+func (s *SmartPortInfoScanner) smartProbeStrategy() {
+	usedProbes := make(map[string]struct{})
+
+	// 阶段1：尝试端口特定探测器（使用 Probe.Ports，按 Rarity 排序）
+	// 注意：端口特定探测器不按 intensity 过滤，因为它们是专门为该端口设计的
+	portProbes := v.GetProbesForPort(s.Port)
+	if len(portProbes) > 0 {
+		if s.tryProbeList(portProbes, usedProbes) {
+			return
+		}
+	}
+
+	// 阶段2：尝试 SSL 端口探测器（使用 Probe.SSLPorts）
+	sslProbes := v.GetSSLProbesForPort(s.Port)
+	if len(sslProbes) > 0 {
+		if s.tryProbeList(sslProbes, usedProbes) {
+			return
+		}
+	}
+
+	// 阶段3：回退到通用探测器（按 Rarity 排序，按 intensity 过滤）
+	allProbes := v.GetAllProbesSortedByRarity()
+	allProbes = portfinger.FilterProbesByIntensity(allProbes, defaultIntensity)
+	// 限制回退探测器数量，避免过度探测
+	maxFallback := 5
+	if len(allProbes) > maxFallback {
+		allProbes = allProbes[:maxFallback]
+	}
+	s.tryProbeList(allProbes, usedProbes)
+
+	// 如果所有探测都失败，标记为未知服务
+	if s.info.Result.Service.Name == "" {
+		s.info.Result.Service.Name = "unknown"
+	}
+}
+
+// tryProbeList 尝试探测器列表
+// 使用 Probe.TotalWaitMS 设置动态超时，实现隐式 NULL 回退
+func (s *SmartPortInfoScanner) tryProbeList(probes []*Probe, usedProbes map[string]struct{}) bool {
+	for _, probe := range probes {
+		if _, used := usedProbes[probe.Name]; used {
+			continue
+		}
+		usedProbes[probe.Name] = struct{}{}
+
+		probeData, err := DecodeData(probe.Data)
+		if err != nil {
+			continue
+		}
+
+		// 使用 TotalWaitMS 设置动态超时
+		waitMS := probe.TotalWaitMS
+		if waitMS <= 0 {
+			waitMS = defaultTotalWaitMS
+		}
+		s.info.setReadTimeout(waitMS)
+
+		response := s.info.Connect(probeData)
+		if len(response) == 0 {
+			// 连接可能被关闭（如服务端返回 EOF），尝试重建连接后继续下一个探针
+			s.reconnectIfNeeded()
+			continue
+		}
+
+		// 尝试匹配（GetInfo 会自动遍历 fallback 数组，包含 NULL 回退）
+		s.info.GetInfo(response, probe)
+		if s.info.Found {
+			return true
+		}
+	}
+
+	return false
+}
+
+// reconnectIfNeeded 强制重建连接
+// 当探针收到空响应时调用，说明连接可能已被服务端关闭
+func (s *SmartPortInfoScanner) reconnectIfNeeded() {
+	// 关闭旧连接
+	if s.info.Conn != nil {
+		_ = s.info.Conn.Close()
+		s.info.Conn = nil
+		s.Conn = nil
+	}
+
+	// 重新建立连接
+	newConn, err := common.WrapperTcpWithTimeout("tcp", fmt.Sprintf("%s:%d", s.Address, s.Port), s.Timeout)
+	if err != nil {
+		return
+	}
+
+	s.info.Conn = newConn
+	s.Conn = newConn
+}
+
+// performSSLSecondStage 执行 SSL 多阶段探测
+// 参考 gonmap 的策略：ssl → ssl-specific probes → https
+func (s *SmartPortInfoScanner) performSSLSecondStage(serviceInfo *ServiceInfo) *ServiceInfo {
+	if serviceInfo.Name != "ssl" {
+		// 不是SSL服务，直接返回
+		return serviceInfo
+	}
+	// 第二阶段：SSL 专用探测器（如 RDP）
+	for _, probeName := range sslSecondProbes {
+		probe, exists := v.ProbesMapKName[probeName]
+		if !exists {
+			continue
+		}
+
+		probeData, err := DecodeData(probe.Data)
+		if err != nil || len(probeData) == 0 {
+			continue
+		}
+		response := s.info.Connect(probeData)
+		if len(response) == 0 {
+			continue
+		}
+
+		// 尝试识别服务
+		s.info.GetInfo(response, &probe)
+		if s.info.Found && s.info.Result.Service.Name != "ssl" {
+			return s.buildServiceInfo()
+		}
+	}
+
+	// 第三阶段：尝试 HTTPS（通过 TLS 发送 HTTP GET）
+	if serviceInfo.Name == "ssl" {
+		newServiceInfo := s.tryHTTPSProbe()
+		if newServiceInfo != nil {
+			return newServiceInfo
+		}
+	}
+
+	return serviceInfo
+}
+
+// tryHTTPSProbe 尝试 HTTPS 探测
+func (s *SmartPortInfoScanner) tryHTTPSProbe() *ServiceInfo {
+	// 使用 GetRequest 探测器
+	probe, exists := v.ProbesMapKName["GetRequest"]
+	if !exists {
+		return nil
+	}
+
+	probeData, err := DecodeData(probe.Data)
+	if err != nil || len(probeData) == 0 {
+		return nil
+	}
+	response := s.info.Connect(probeData)
+	if len(response) == 0 {
+		return nil
+	}
+
+	// 尝试识别服务
+	s.info.GetInfo(response, &probe)
+	if s.info.Found {
+		serviceInfo := s.buildServiceInfo()
+		// 自动转换 http → https
+		if serviceInfo.Name == "http" {
+			serviceInfo.Name = "https"
+		}
+		return serviceInfo
+	}
+
+	return nil
+}
+
+// buildServiceInfo 构建ServiceInfo结果
+func (s *SmartPortInfoScanner) buildServiceInfo() *ServiceInfo {
+	result := &s.info.Result
+
+	serviceInfo := &ServiceInfo{
+		Name:    result.Service.Name,
+		Banner:  result.Banner,
+		Version: result.Service.Extras["version"],
+		Extras:  make(map[string]string),
+	}
+
+	// 复制额外信息
+	for k, v := range result.Service.Extras {
+		serviceInfo.Extras[k] = v
+	}
+	return serviceInfo
+}
+
+// tryProbes 尝试使用指定的探测器列表检查响应
+func (i *Info) tryProbes(response []byte, probes []*Probe) bool {
+	for _, probe := range probes {
+		i.GetInfo(response, probe)
+		if i.Found {
+			return true
+		}
+	}
+	return false
+}
+
+// GetInfo 分析响应数据并提取服务信息
+func (i *Info) GetInfo(response []byte, probe *Probe) {
+	// 响应数据有效性检查
+	if len(response) <= 0 {
+		common.LogDebug("响应数据为空")
+		return
+	}
+
+	result := &i.Result
+	var (
+		softMatch Match
+		softFound bool
+	)
+
+	// 遍历 fallback 数组尝试匹配（参考 Nmap 的 servicescan_read_handler）
+	// fallback 数组顺序: [自身, fallback指令中的探测器..., NULL探测器(TCP)]
+	for depth := 0; depth < portfinger.MaxFallbacks+1; depth++ {
+		fallback := probe.Fallbacks[depth]
+		if fallback == nil {
+			break
+		}
+
+		// 尝试匹配当前 fallback 探测器的规则
+		if matched, match := i.processMatches(response, fallback.Matchs); matched {
+			return // 硬匹配成功，直接返回
+		} else if match != nil && !softFound {
+			// 记录第一个软匹配
+			softFound = true
+			softMatch = *match
+		}
+	}
+
+	// 处理未找到匹配的情况
+	if !i.Found {
+		i.handleNoMatch(response, result, softFound, softMatch)
+	}
+}
+
+// processMatches 处理匹配规则集
+func (i *Info) processMatches(response []byte, matches *[]Match) (bool, *Match) {
+	var softMatch *Match
+
+	for _, match := range *matches {
+		if !match.MatchPattern(response) {
+			continue
+		}
+
+		if !match.IsSoft {
+			i.handleHardMatch(response, &match)
+			return true, nil
+		} else if softMatch == nil {
+			tmpMatch := match
+			softMatch = &tmpMatch
+		}
+	}
+
+	return false, softMatch
+}
+
+// handleHardMatch 处理硬匹配结果
+func (i *Info) handleHardMatch(response []byte, match *Match) {
+	result := &i.Result
+	extras := match.ParseVersionInfo(response)
+	extrasMap := extras.ToMap()
+
+	result.Service.Name = match.Service
+	result.Extras = extrasMap
+	result.Banner = portfinger.TrimBanner(string(response))
+	result.Service.Extras = extrasMap
+
+	// 特殊处理 microsoft-ds 服务
+	if result.Service.Name == "microsoft-ds" {
+		common.LogDebug("特殊处理 microsoft-ds 服务")
+		result.Service.Extras["hostname"] = result.Banner
+	}
+
+	i.Found = true
+	common.LogDebug(fmt.Sprintf("服务识别结果: %s, Banner: %s", result.Service.Name, result.Banner))
+}
+
+// handleNoMatch 处理未找到匹配的情况
+func (i *Info) handleNoMatch(response []byte, result *Result, softFound bool, softMatch Match) {
+	result.Banner = portfinger.TrimBanner(string(response))
+
+	if !softFound {
+		// 尝试识别 HTTP 服务（大小写不敏感）
+		bannerLower := strings.ToLower(result.Banner)
+		if strings.Contains(bannerLower, "http/") ||
+			strings.Contains(bannerLower, "html") {
+			common.LogDebug("识别为HTTP服务")
+			result.Service.Name = "http"
+		} else {
+			common.LogDebug("未知服务")
+			result.Service.Name = "unknown"
+		}
+	} else {
+		extras := softMatch.ParseVersionInfo(response)
+		result.Service.Extras = extras.ToMap()
+		result.Service.Name = softMatch.Service
+		i.Found = true
+		common.LogDebug(fmt.Sprintf("软匹配服务: %s", result.Service.Name))
+	}
+}
+
+// Connect 发送数据并获取响应
+func (i *Info) Connect(msg []byte) []byte {
+	_ = i.Write(msg)
+	reply, _ := i.Read()
+	return reply
+}
+
+// setReadTimeout 设置读取超时时间（毫秒）
+func (i *Info) setReadTimeout(ms int) {
+	if ms > 0 {
+		i.readTimeoutMS = ms
+	}
+}
+
+// getReadTimeout 获取当前读取超时时间
+func (i *Info) getReadTimeout() time.Duration {
+	if i.readTimeoutMS > 0 {
+		return time.Duration(i.readTimeoutMS) * time.Millisecond
+	}
+	return time.Duration(defaultReadTimeoutMS) * time.Millisecond
+}
+
+// WrTimeout 默认读写超时时间(秒)
+const WrTimeout = 3
+
+// currentReadTimeoutMS 当前读取超时时间（毫秒），用于动态调整
+var defaultReadTimeoutMS = WrTimeout * 1000
+
+// Write 写入数据到连接
+func (i *Info) Write(msg []byte) error {
+	if i.Conn == nil {
+		return nil
+	}
+
+	// 设置写入超时
+	_ = i.Conn.SetWriteDeadline(time.Now().Add(time.Second * time.Duration(WrTimeout)))
+
+	// 写入数据
+	_, err := i.Conn.Write(msg)
+	if err != nil && strings.Contains(err.Error(), "close") {
+		// 关闭旧连接并清理
+		oldConn := i.Conn
+		i.Conn = nil
+		_ = oldConn.Close()
+
+		// 尝试重新连接 - 支持SOCKS5代理
+		newConn, retryErr := common.WrapperTcpWithTimeout("tcp", fmt.Sprintf("%s:%d", i.Address, i.Port), time.Duration(6)*time.Second)
+		if retryErr != nil {
+			return retryErr
+		}
+
+		// 设置新连接并重试写入
+		i.Conn = newConn
+		_ = i.Conn.SetWriteDeadline(time.Now().Add(time.Second * time.Duration(WrTimeout)))
+		_, err = i.Conn.Write(msg)
+
+		// 如果重试写入失败，清理新连接
+		if err != nil {
+			_ = i.Conn.Close()
+			i.Conn = nil
+		}
+	}
+
+	// 记录发送的数据
+	if err == nil {
+		i.Result.Send = msg
+	}
+
+	return err
+}
+
+// Read 从连接读取响应
+func (i *Info) Read() ([]byte, error) {
+	if i.Conn == nil {
+		return nil, nil
+	}
+
+	// 设置读取超时（使用动态超时）
+	_ = i.Conn.SetReadDeadline(time.Now().Add(i.getReadTimeout()))
+
+	// 读取数据
+	result, err := readFromConn(i.Conn)
+	if err != nil && strings.Contains(err.Error(), "close") {
+		return result, err
+	}
+
+	// 记录接收到的数据
+	if len(result) > 0 {
+		i.Result.Recv = result
+	}
+
+	return result, err
+}
+
+// readFromConn 从连接读取数据的辅助函数
+// 使用 sync.Pool 复用缓冲区，减少高并发扫描时的 GC 压力
+func readFromConn(conn net.Conn) ([]byte, error) {
+	const size = 2 * 1024
+
+	// 从对象池获取缓冲区
+	bufInterface := readBufPool.Get()
+	bufPtr, ok := bufInterface.(*[]byte)
+	if !ok || bufPtr == nil {
+		buf := make([]byte, size)
+		bufPtr = &buf
+	}
+	buf := *bufPtr
+	defer readBufPool.Put(bufPtr)
+
+	var result []byte
+
+	for {
+		count, err := conn.Read(buf)
+
+		if count > 0 {
+			result = append(result, buf[:count]...)
+		}
+
+		if err != nil {
+			if len(result) > 0 {
+				return result, nil
+			}
+			if errors.Is(err, io.EOF) {
+				return result, nil
+			}
+			return result, err
+		}
+
+		if count < size {
+			return result, nil
+		}
+	}
+}