mirror of
https://github.com/shadow1ng/fscan.git
synced 2026-09-22 03:10:42 +08:00
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
This commit is contained in:
ZacharyZcR
@@ -0,0 +1,827 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/shadow1ng/fscan/common"
|
||||
)
|
||||
|
||||
/*
|
||||
service_scanner_test.go - ServiceScanStrategy核心逻辑测试
|
||||
|
||||
注意：service_scanner.go 包含大量网络IO和全局状态依赖。
|
||||
本测试文件专注于可测试的纯逻辑和算法正确性：
|
||||
1. parsePortList - 端口解析逻辑
|
||||
2. shouldPerformLivenessCheck - 存活检测判断
|
||||
3. convertToTargetInfos - host:port数据转换
|
||||
|
||||
不测试的部分（需要集成测试）：
|
||||
- Execute, performHostScan - 网络IO + 全局状态
|
||||
- discoverTargets - 依赖CheckLive, EnhancedPortScan
|
||||
- handleUDPPorts - 依赖全局common.Port
|
||||
- LogPluginInfo - 依赖插件系统和日志
|
||||
|
||||
"端口解析和数据转换是纯函数，应该测试。
|
||||
网络扫描和插件管理是副作用，需要集成测试。"
|
||||
*/
|
||||
|
||||
// =============================================================================
|
||||
// 核心逻辑测试：端口解析
|
||||
// =============================================================================
|
||||
|
||||
/*
|
||||
端口列表解析 - parsePortList 方法测试
|
||||
|
||||
测试价值：用户指定端口解析是扫描器的核心入口，解析错误会导致：
|
||||
- 扫描错误的端口
|
||||
- 跳过用户指定的端口
|
||||
- 扫描非法端口导致崩溃
|
||||
|
||||
"端口解析看起来简单，但涉及字符串转数字、范围验证、错误处理。
|
||||
这是真实的业务逻辑，bug会直接影响用户体验。必须测试。"
|
||||
*/
|
||||
|
||||
// TestParsePortList_BasicParsing 测试基本的端口解析
|
||||
func TestParsePortList_BasicParsing(t *testing.T) {
|
||||
s := NewServiceScanStrategy()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected []int
|
||||
}{
|
||||
{
|
||||
name: "单个端口",
|
||||
input: "22",
|
||||
expected: []int{22},
|
||||
},
|
||||
{
|
||||
name: "两个端口-逗号分隔",
|
||||
input: "22,80",
|
||||
expected: []int{22, 80},
|
||||
},
|
||||
{
|
||||
name: "多个端口",
|
||||
input: "22,80,443,3306",
|
||||
expected: []int{22, 80, 443, 3306},
|
||||
},
|
||||
{
|
||||
name: "空字符串",
|
||||
input: "",
|
||||
expected: []int{},
|
||||
},
|
||||
{
|
||||
name: "all关键字",
|
||||
input: "all",
|
||||
expected: []int{},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := s.parsePortList(tt.input)
|
||||
if !intSlicesEqual(result, tt.expected) {
|
||||
t.Errorf("parsePortList(%q) = %v, want %v",
|
||||
tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestParsePortList_Whitespace 测试空格处理
|
||||
func TestParsePortList_Whitespace(t *testing.T) {
|
||||
s := NewServiceScanStrategy()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected []int
|
||||
}{
|
||||
{
|
||||
name: "端口前后有空格",
|
||||
input: " 22 ",
|
||||
expected: []int{22},
|
||||
},
|
||||
{
|
||||
name: "逗号前后有空格",
|
||||
input: "22 , 80",
|
||||
expected: []int{22, 80},
|
||||
},
|
||||
{
|
||||
name: "多个空格",
|
||||
input: " 22 , 80 , 443 ",
|
||||
expected: []int{22, 80, 443},
|
||||
},
|
||||
{
|
||||
name: "Tab字符",
|
||||
input: "22\t,\t80",
|
||||
expected: []int{22, 80},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := s.parsePortList(tt.input)
|
||||
if !intSlicesEqual(result, tt.expected) {
|
||||
t.Errorf("parsePortList(%q) = %v, want %v",
|
||||
tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestParsePortList_RangeValidation 测试端口范围验证
|
||||
func TestParsePortList_RangeValidation(t *testing.T) {
|
||||
s := NewServiceScanStrategy()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected []int
|
||||
note string
|
||||
}{
|
||||
{
|
||||
name: "最小有效端口-1",
|
||||
input: "1",
|
||||
expected: []int{1},
|
||||
note: "端口1是最小的有效端口",
|
||||
},
|
||||
{
|
||||
name: "最大有效端口-65535",
|
||||
input: "65535",
|
||||
expected: []int{65535},
|
||||
note: "端口65535是最大的有效端口",
|
||||
},
|
||||
{
|
||||
name: "边界值-1和65535",
|
||||
input: "1,65535",
|
||||
expected: []int{1, 65535},
|
||||
note: "测试边界值组合",
|
||||
},
|
||||
{
|
||||
name: "端口0-无效",
|
||||
input: "0",
|
||||
expected: []int{},
|
||||
note: "端口0应该被忽略",
|
||||
},
|
||||
{
|
||||
name: "端口65536-超出范围",
|
||||
input: "65536",
|
||||
expected: []int{},
|
||||
note: "超出最大端口应该被忽略",
|
||||
},
|
||||
{
|
||||
name: "负数端口",
|
||||
input: "-1",
|
||||
expected: []int{},
|
||||
note: "负数端口应该被忽略",
|
||||
},
|
||||
{
|
||||
name: "混合有效和无效端口",
|
||||
input: "0,22,80,65536,443",
|
||||
expected: []int{22, 80, 443},
|
||||
note: "只保留有效端口",
|
||||
},
|
||||
{
|
||||
name: "常见端口范围边界",
|
||||
input: "1,1023,1024,49151,49152,65535",
|
||||
expected: []int{1, 1023, 1024, 49151, 49152, 65535},
|
||||
note: "测试特权端口、注册端口、动态端口的边界",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := s.parsePortList(tt.input)
|
||||
if !intSlicesEqual(result, tt.expected) {
|
||||
t.Errorf("parsePortList(%q) = %v, want %v\nNote: %s",
|
||||
tt.input, result, tt.expected, tt.note)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestParsePortList_InvalidInput 测试非法输入处理
|
||||
func TestParsePortList_InvalidInput(t *testing.T) {
|
||||
s := NewServiceScanStrategy()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected []int
|
||||
note string
|
||||
}{
|
||||
{
|
||||
name: "非数字字符",
|
||||
input: "abc",
|
||||
expected: []int{},
|
||||
note: "非数字应该被忽略",
|
||||
},
|
||||
{
|
||||
name: "混合数字和字母",
|
||||
input: "22,abc,80",
|
||||
expected: []int{22, 80},
|
||||
note: "只提取有效的数字",
|
||||
},
|
||||
{
|
||||
name: "小数",
|
||||
input: "22.5",
|
||||
expected: []int{},
|
||||
note: "小数应该被忽略",
|
||||
},
|
||||
{
|
||||
name: "科学计数法",
|
||||
input: "1e3",
|
||||
expected: []int{},
|
||||
note: "科学计数法应该被忽略",
|
||||
},
|
||||
{
|
||||
name: "空白项",
|
||||
input: "22,,80",
|
||||
expected: []int{22, 80},
|
||||
note: "空白项应该被跳过",
|
||||
},
|
||||
{
|
||||
name: "仅逗号",
|
||||
input: ",,,",
|
||||
expected: []int{},
|
||||
note: "仅逗号应该返回空列表",
|
||||
},
|
||||
{
|
||||
name: "超大数字",
|
||||
input: "999999",
|
||||
expected: []int{},
|
||||
note: "超大数字应该被忽略",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := s.parsePortList(tt.input)
|
||||
if !intSlicesEqual(result, tt.expected) {
|
||||
t.Errorf("parsePortList(%q) = %v, want %v\nNote: %s",
|
||||
tt.input, result, tt.expected, tt.note)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestParsePortList_ProductionScenarios 测试生产环境真实场景
|
||||
func TestParsePortList_ProductionScenarios(t *testing.T) {
|
||||
s := NewServiceScanStrategy()
|
||||
|
||||
t.Run("常见Web端口", func(t *testing.T) {
|
||||
input := "80,443,8080,8443"
|
||||
expected := []int{80, 443, 8080, 8443}
|
||||
result := s.parsePortList(input)
|
||||
if !intSlicesEqual(result, expected) {
|
||||
t.Errorf("应该正确解析常见Web端口")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("数据库端口", func(t *testing.T) {
|
||||
input := "3306,5432,1433,27017"
|
||||
expected := []int{3306, 5432, 1433, 27017}
|
||||
result := s.parsePortList(input)
|
||||
if !intSlicesEqual(result, expected) {
|
||||
t.Errorf("应该正确解析常见数据库端口")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("用户复制粘贴带空格", func(t *testing.T) {
|
||||
// 用户从文档复制 "22, 80, 443" 粘贴到命令行
|
||||
input := "22, 80, 443"
|
||||
expected := []int{22, 80, 443}
|
||||
result := s.parsePortList(input)
|
||||
if !intSlicesEqual(result, expected) {
|
||||
t.Errorf("应该正确处理用户复制粘贴的空格")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("用户手误输入无效端口", func(t *testing.T) {
|
||||
// 用户错误输入了0端口
|
||||
input := "0,22,80"
|
||||
expected := []int{22, 80}
|
||||
result := s.parsePortList(input)
|
||||
if !intSlicesEqual(result, expected) {
|
||||
t.Errorf("应该过滤掉无效端口0")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("高端口号-动态端口", func(t *testing.T) {
|
||||
// 测试动态端口范围 49152-65535
|
||||
input := "49152,50000,60000,65535"
|
||||
expected := []int{49152, 50000, 60000, 65535}
|
||||
result := s.parsePortList(input)
|
||||
if !intSlicesEqual(result, expected) {
|
||||
t.Errorf("应该正确解析高端口号")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// TestParsePortList_ReturnValue 测试返回值特性
|
||||
func TestParsePortList_ReturnValue(t *testing.T) {
|
||||
s := NewServiceScanStrategy()
|
||||
|
||||
t.Run("返回切片而非nil", func(t *testing.T) {
|
||||
result := s.parsePortList("")
|
||||
if result == nil {
|
||||
t.Error("空输入应该返回空切片，而不是nil")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("端口不重复-但不保证去重", func(t *testing.T) {
|
||||
// 注意：当前实现不去重，如果用户输入 "22,22"，会返回 [22, 22]
|
||||
// 这是可以接受的，因为上层逻辑会处理重复
|
||||
input := "22,22"
|
||||
result := s.parsePortList(input)
|
||||
// 这里我们只测试解析是否正确，不测试去重
|
||||
if len(result) != 2 || result[0] != 22 || result[1] != 22 {
|
||||
t.Errorf("当前实现不去重，应该返回两个22")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// intSlicesEqual 比较两个int切片是否相等
|
||||
func intSlicesEqual(a, b []int) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
for i := range a {
|
||||
if a[i] != b[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// 存活检测判断测试
|
||||
// =============================================================================
|
||||
|
||||
// TestShouldPerformLivenessCheck 测试存活检测判断逻辑
|
||||
func TestShouldPerformLivenessCheck(t *testing.T) {
|
||||
strategy := NewServiceScanStrategy()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
hosts []string
|
||||
disablePing bool
|
||||
expected bool
|
||||
}{
|
||||
{
|
||||
name: "多主机+允许Ping",
|
||||
hosts: []string{"192.168.1.1", "192.168.1.2", "192.168.1.3"},
|
||||
disablePing: false,
|
||||
expected: true,
|
||||
},
|
||||
{
|
||||
name: "多主机+禁用Ping",
|
||||
hosts: []string{"192.168.1.1", "192.168.1.2"},
|
||||
disablePing: true,
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "单主机+允许Ping",
|
||||
hosts: []string{"192.168.1.1"},
|
||||
disablePing: false,
|
||||
expected: false, // 单主机不需要存活检测
|
||||
},
|
||||
{
|
||||
name: "单主机+禁用Ping",
|
||||
hosts: []string{"192.168.1.1"},
|
||||
disablePing: true,
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "空主机列表+允许Ping",
|
||||
hosts: []string{},
|
||||
disablePing: false,
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "空主机列表+禁用Ping",
|
||||
hosts: []string{},
|
||||
disablePing: true,
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "两个主机-边界情况",
|
||||
hosts: []string{"192.168.1.1", "192.168.1.2"},
|
||||
disablePing: false,
|
||||
expected: true, // >1 触发检测
|
||||
},
|
||||
{
|
||||
name: "大量主机",
|
||||
hosts: make([]string, 100),
|
||||
disablePing: false,
|
||||
expected: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// 设置 Config 对象
|
||||
cfg := common.GetGlobalConfig()
|
||||
oldDisablePing := cfg.DisablePing
|
||||
cfg.DisablePing = tt.disablePing
|
||||
defer func() {
|
||||
cfg.DisablePing = oldDisablePing
|
||||
}()
|
||||
|
||||
result := strategy.shouldPerformLivenessCheck(tt.hosts, cfg)
|
||||
|
||||
if result != tt.expected {
|
||||
t.Errorf("shouldPerformLivenessCheck() = %v, 期望 %v (hosts=%d, disablePing=%v)",
|
||||
result, tt.expected, len(tt.hosts), tt.disablePing)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// 数据转换测试
|
||||
// =============================================================================
|
||||
|
||||
// TestConvertToTargetInfos 测试端口列表转目标信息
|
||||
func TestConvertToTargetInfos(t *testing.T) {
|
||||
strategy := NewServiceScanStrategy()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
ports []string
|
||||
baseInfo common.HostInfo
|
||||
expectedLen int
|
||||
validateFunc func(*testing.T, []common.HostInfo)
|
||||
}{
|
||||
{
|
||||
name: "单个目标",
|
||||
ports: []string{"192.168.1.1:80"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 1,
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
if infos[0].Host != "192.168.1.1" {
|
||||
t.Errorf("Host = %q, 期望 '192.168.1.1'", infos[0].Host)
|
||||
}
|
||||
if infos[0].Port != 80 {
|
||||
t.Errorf("Ports = %q, 期望 '80'", infos[0].Port)
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "多个目标",
|
||||
ports: []string{"192.168.1.1:80", "192.168.1.2:443", "192.168.1.3:8080"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 3,
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
expected := []struct {
|
||||
host string
|
||||
port int
|
||||
}{
|
||||
{"192.168.1.1", 80},
|
||||
{"192.168.1.2", 443},
|
||||
{"192.168.1.3", 8080},
|
||||
}
|
||||
for i, exp := range expected {
|
||||
if infos[i].Host != exp.host {
|
||||
t.Errorf("infos[%d].Host = %q, 期望 %q", i, infos[i].Host, exp.host)
|
||||
}
|
||||
if infos[i].Port != exp.port {
|
||||
t.Errorf("infos[%d].Port = %d, 期望 %d", i, infos[i].Port, exp.port)
|
||||
}
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "继承baseInfo属性",
|
||||
ports: []string{"192.168.1.1:80"},
|
||||
baseInfo: common.HostInfo{
|
||||
URL: "http://example.com",
|
||||
Info: []string{"info1", "info2"},
|
||||
},
|
||||
expectedLen: 1,
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
if infos[0].URL != "http://example.com" {
|
||||
t.Errorf("URL = %q, 期望 'http://example.com'", infos[0].URL)
|
||||
}
|
||||
if len(infos[0].Info) != 2 {
|
||||
t.Errorf("Infostr长度 = %d, 期望 2", len(infos[0].Info))
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "空端口列表",
|
||||
ports: []string{},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0,
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "非法格式-无冒号",
|
||||
ports: []string{"192.168.1.1"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0, // 非法格式被过滤
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "非法格式-多个冒号",
|
||||
ports: []string{"192.168.1.1:80:443"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0, // 非法格式被过滤
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "混合-有效和无效",
|
||||
ports: []string{"192.168.1.1:80", "invalid", "192.168.1.2:443"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 2,
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
if infos[0].Host != "192.168.1.1" || infos[0].Port != 80 {
|
||||
t.Errorf("第一个目标错误: %s:%d", infos[0].Host, infos[0].Port)
|
||||
}
|
||||
if infos[1].Host != "192.168.1.2" || infos[1].Port != 443 {
|
||||
t.Errorf("第二个目标错误: %s:%d", infos[1].Host, infos[1].Port)
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "IPv6地址",
|
||||
ports: []string{"::1:8080"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0, // Split会产生多个部分，被判定为非法
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "域名+端口",
|
||||
ports: []string{"example.com:80", "test.local:443"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 2,
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
if infos[0].Host != "example.com" {
|
||||
t.Errorf("Host = %q, 期望 'example.com'", infos[0].Host)
|
||||
}
|
||||
if infos[1].Host != "test.local" {
|
||||
t.Errorf("Host = %q, 期望 'test.local'", infos[1].Host)
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "端口为0-被拒绝",
|
||||
ports: []string{"192.168.1.1:0"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0, // 修复后：端口0被验证并拒绝
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "高端口-65535合法",
|
||||
ports: []string{"192.168.1.1:65535"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 1,
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
if infos[0].Port != 65535 {
|
||||
t.Errorf("Ports = %q, 期望 '65535'", infos[0].Port)
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "超大端口-被拒绝",
|
||||
ports: []string{"192.168.1.1:65536"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0, // 修复后：端口65536被拒绝
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "负数端口-被拒绝",
|
||||
ports: []string{"192.168.1.1:-80"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 0, // 修复后：负数端口被拒绝
|
||||
validateFunc: nil,
|
||||
},
|
||||
{
|
||||
name: "混合-过滤非法端口",
|
||||
ports: []string{"192.168.1.1:80", "192.168.1.2:0", "192.168.1.3:65536", "192.168.1.4:443"},
|
||||
baseInfo: common.HostInfo{},
|
||||
expectedLen: 2, // 只有80和443合法
|
||||
validateFunc: func(t *testing.T, infos []common.HostInfo) {
|
||||
if infos[0].Port != 80 {
|
||||
t.Errorf("第一个端口 = %q, 期望 '80'", infos[0].Port)
|
||||
}
|
||||
if infos[1].Port != 443 {
|
||||
t.Errorf("第二个端口 = %q, 期望 '443'", infos[1].Port)
|
||||
}
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := strategy.convertToTargetInfos(tt.ports, tt.baseInfo)
|
||||
|
||||
// 验证长度
|
||||
if len(result) != tt.expectedLen {
|
||||
t.Errorf("convertToTargetInfos() 长度 = %d, 期望 %d", len(result), tt.expectedLen)
|
||||
}
|
||||
|
||||
// 执行自定义验证
|
||||
if tt.validateFunc != nil && len(result) > 0 {
|
||||
tt.validateFunc(t, result)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// 边界情况测试
|
||||
// =============================================================================
|
||||
|
||||
// TestConvertToTargetInfos_EdgeCases 测试边界情况
|
||||
func TestConvertToTargetInfos_EdgeCases(t *testing.T) {
|
||||
strategy := NewServiceScanStrategy()
|
||||
|
||||
t.Run("空字符串端口", func(t *testing.T) {
|
||||
ports := []string{""}
|
||||
result := strategy.convertToTargetInfos(ports, common.HostInfo{})
|
||||
if len(result) != 0 {
|
||||
t.Errorf("空字符串应被过滤, 实际长度 %d", len(result))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("只有冒号", func(t *testing.T) {
|
||||
ports := []string{":"}
|
||||
result := strategy.convertToTargetInfos(ports, common.HostInfo{})
|
||||
// 修复后：Split产生["", ""]，TrimSpace后都是空，被过滤
|
||||
if len(result) != 0 {
|
||||
t.Errorf("只有冒号应被过滤, 实际长度 %d", len(result))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("冒号前后有空格", func(t *testing.T) {
|
||||
ports := []string{"192.168.1.1 : 80"}
|
||||
result := strategy.convertToTargetInfos(ports, common.HostInfo{})
|
||||
// 修复后：Split产生["192.168.1.1 ", " 80"]，TrimSpace后去除空格
|
||||
if len(result) != 1 {
|
||||
t.Errorf("带空格的冒号应产生1个结果, 实际长度 %d", len(result))
|
||||
}
|
||||
if len(result) > 0 {
|
||||
// 修复后：空格应被去除
|
||||
if result[0].Host != "192.168.1.1" {
|
||||
t.Errorf("Host = %q, 期望 '192.168.1.1'（空格已去除）", result[0].Host)
|
||||
}
|
||||
if result[0].Port != 80 {
|
||||
t.Errorf("Ports = %q, 期望 '80'（空格已去除）", result[0].Port)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("大量目标", func(t *testing.T) {
|
||||
var ports []string
|
||||
for i := 1; i <= 1000; i++ {
|
||||
ports = append(ports, "192.168.1.1:"+string(rune(i)))
|
||||
}
|
||||
result := strategy.convertToTargetInfos(ports, common.HostInfo{})
|
||||
// 由于端口是rune转换，大部分会失败，只验证不panic
|
||||
if result == nil {
|
||||
t.Error("不应返回nil")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// TestParsePortList_SpecialCases 测试特殊情况
|
||||
func TestParsePortList_SpecialCases(t *testing.T) {
|
||||
strategy := NewServiceScanStrategy()
|
||||
|
||||
t.Run("Unicode空格", func(t *testing.T) {
|
||||
// 包含全角空格
|
||||
result := strategy.parsePortList("80，443")
|
||||
// 全角逗号不会被分割，整个字符串作为一个部分
|
||||
if len(result) != 0 {
|
||||
t.Errorf("全角逗号应导致解析失败, 实际长度 %d", len(result))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("制表符分隔", func(t *testing.T) {
|
||||
result := strategy.parsePortList("80\t443")
|
||||
// 制表符不是逗号，不会分割
|
||||
if len(result) != 0 {
|
||||
t.Errorf("制表符不应分割端口, 实际长度 %d", len(result))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("换行符", func(t *testing.T) {
|
||||
result := strategy.parsePortList("80\n443")
|
||||
// 换行符不是逗号
|
||||
if len(result) != 0 {
|
||||
t.Errorf("换行符不应分割端口, 实际长度 %d", len(result))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// TestShouldPerformLivenessCheck_ConcurrentSafety 测试并发安全性
|
||||
func TestShouldPerformLivenessCheck_ConcurrentSafety(t *testing.T) {
|
||||
strategy := NewServiceScanStrategy()
|
||||
hosts := []string{"192.168.1.1", "192.168.1.2"}
|
||||
|
||||
// 保存原始值
|
||||
cfg := common.GetGlobalConfig()
|
||||
oldDisablePing := cfg.DisablePing
|
||||
defer func() {
|
||||
cfg.DisablePing = oldDisablePing
|
||||
}()
|
||||
|
||||
cfg.DisablePing = false
|
||||
|
||||
// 并发调用
|
||||
done := make(chan bool)
|
||||
for i := 0; i < 100; i++ {
|
||||
go func() {
|
||||
_ = strategy.shouldPerformLivenessCheck(hosts, cfg)
|
||||
done <- true
|
||||
}()
|
||||
}
|
||||
|
||||
// 等待所有goroutine完成
|
||||
for i := 0; i < 100; i++ {
|
||||
<-done
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// 深拷贝测试
|
||||
// =============================================================================
|
||||
|
||||
// TestConvertToTargetInfos_DeepCopy 测试Infostr深拷贝
|
||||
func TestConvertToTargetInfos_DeepCopy(t *testing.T) {
|
||||
strategy := NewServiceScanStrategy()
|
||||
|
||||
t.Run("Infostr深拷贝验证", func(t *testing.T) {
|
||||
baseInfo := common.HostInfo{
|
||||
Info: []string{"info1", "info2"},
|
||||
}
|
||||
|
||||
// 转换两个目标
|
||||
result := strategy.convertToTargetInfos(
|
||||
[]string{"192.168.1.1:80", "192.168.1.2:80"},
|
||||
baseInfo,
|
||||
)
|
||||
|
||||
if len(result) != 2 {
|
||||
t.Fatalf("期望2个结果, 实际 %d", len(result))
|
||||
}
|
||||
|
||||
// 验证初始状态：两个target的Infostr应该相等但不共享底层数组
|
||||
if len(result[0].Info) != 2 || len(result[1].Info) != 2 {
|
||||
t.Error("Infostr应被正确复制")
|
||||
}
|
||||
|
||||
// 关键测试：修改第一个target的Infostr
|
||||
result[0].Info = append(result[0].Info, "modified")
|
||||
|
||||
// 验证第二个target的Infostr未被影响（深拷贝成功）
|
||||
if len(result[1].Info) != 2 {
|
||||
t.Errorf("深拷贝失败: result[1].Info长度 = %d, 期望 2 (不应受result[0]影响)",
|
||||
len(result[1].Info))
|
||||
}
|
||||
|
||||
// 验证baseInfo的Infostr也未被影响
|
||||
if len(baseInfo.Info) != 2 {
|
||||
t.Errorf("深拷贝失败: baseInfo.Info长度 = %d, 期望 2 (不应受修改影响)",
|
||||
len(baseInfo.Info))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("空Infostr不panic", func(t *testing.T) {
|
||||
baseInfo := common.HostInfo{
|
||||
Info: nil,
|
||||
}
|
||||
|
||||
result := strategy.convertToTargetInfos(
|
||||
[]string{"192.168.1.1:80"},
|
||||
baseInfo,
|
||||
)
|
||||
|
||||
if len(result) != 1 {
|
||||
t.Fatalf("期望1个结果, 实际 %d", len(result))
|
||||
}
|
||||
|
||||
// 验证不会panic
|
||||
if result[0].Info != nil {
|
||||
t.Error("nil Infostr应保持nil")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("空slice不分配内存", func(t *testing.T) {
|
||||
baseInfo := common.HostInfo{
|
||||
Info: []string{},
|
||||
}
|
||||
|
||||
result := strategy.convertToTargetInfos(
|
||||
[]string{"192.168.1.1:80"},
|
||||
baseInfo,
|
||||
)
|
||||
|
||||
// 空slice应该被跳过深拷贝（性能优化）
|
||||
if len(result) != 1 {
|
||||
t.Fatalf("期望1个结果, 实际 %d", len(result))
|
||||
}
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user