mirror of
https://github.com/shadow1ng/fscan.git
synced 2025-07-13 04:42:41 +08:00
878 lines
24 KiB
Go
878 lines
24 KiB
Go
package Core
|
||
|
||
import (
|
||
_ "embed"
|
||
"encoding/hex"
|
||
"fmt"
|
||
"github.com/shadow1ng/fscan/Common"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
)
|
||
|
||
//go:embed nmap-service-probes.txt
|
||
var ProbeString string
|
||
|
||
var v VScan // 改为VScan类型而不是指针
|
||
|
||
type VScan struct {
|
||
Exclude string
|
||
AllProbes []Probe
|
||
UdpProbes []Probe
|
||
Probes []Probe
|
||
ProbesMapKName map[string]Probe
|
||
}
|
||
|
||
type Probe struct {
|
||
Name string // 探测器名称
|
||
Data string // 探测数据
|
||
Protocol string // 协议
|
||
Ports string // 端口范围
|
||
SSLPorts string // SSL端口范围
|
||
|
||
TotalWaitMS int // 总等待时间
|
||
TCPWrappedMS int // TCP包装等待时间
|
||
Rarity int // 稀有度
|
||
Fallback string // 回退探测器名称
|
||
|
||
Matchs *[]Match // 匹配规则列表
|
||
}
|
||
|
||
type Match struct {
|
||
IsSoft bool // 是否为软匹配
|
||
Service string // 服务名称
|
||
Pattern string // 匹配模式
|
||
VersionInfo string // 版本信息格式
|
||
FoundItems []string // 找到的项目
|
||
PatternCompiled *regexp.Regexp // 编译后的正则表达式
|
||
}
|
||
|
||
type Directive struct {
|
||
DirectiveName string
|
||
Flag string
|
||
Delimiter string
|
||
DirectiveStr string
|
||
}
|
||
|
||
type Extras struct {
|
||
VendorProduct string
|
||
Version string
|
||
Info string
|
||
Hostname string
|
||
OperatingSystem string
|
||
DeviceType string
|
||
CPE string
|
||
}
|
||
|
||
func init() {
|
||
Common.LogDebug("开始初始化全局变量")
|
||
|
||
v = VScan{} // 直接初始化VScan结构体
|
||
v.Init()
|
||
|
||
// 获取并检查 NULL 探测器
|
||
if nullProbe, ok := v.ProbesMapKName["NULL"]; ok {
|
||
Common.LogDebug(fmt.Sprintf("成功获取NULL探测器，Data长度: %d", len(nullProbe.Data)))
|
||
null = &nullProbe
|
||
} else {
|
||
Common.LogDebug("警告: 未找到NULL探测器")
|
||
}
|
||
|
||
// 获取并检查 GenericLines 探测器
|
||
if commonProbe, ok := v.ProbesMapKName["GenericLines"]; ok {
|
||
Common.LogDebug(fmt.Sprintf("成功获取GenericLines探测器，Data长度: %d", len(commonProbe.Data)))
|
||
common = &commonProbe
|
||
} else {
|
||
Common.LogDebug("警告: 未找到GenericLines探测器")
|
||
}
|
||
|
||
Common.LogDebug("全局变量初始化完成")
|
||
}
|
||
|
||
// 解析指令语法,返回指令结构
|
||
func (p *Probe) getDirectiveSyntax(data string) (directive Directive) {
|
||
Common.LogDebug("开始解析指令语法，输入数据: " + data)
|
||
|
||
directive = Directive{}
|
||
// 查找第一个空格的位置
|
||
blankIndex := strings.Index(data, " ")
|
||
if blankIndex == -1 {
|
||
Common.LogDebug("未找到空格分隔符")
|
||
return directive
|
||
}
|
||
|
||
// 解析各个字段
|
||
directiveName := data[:blankIndex]
|
||
Flag := data[blankIndex+1 : blankIndex+2]
|
||
delimiter := data[blankIndex+2 : blankIndex+3]
|
||
directiveStr := data[blankIndex+3:]
|
||
|
||
directive.DirectiveName = directiveName
|
||
directive.Flag = Flag
|
||
directive.Delimiter = delimiter
|
||
directive.DirectiveStr = directiveStr
|
||
|
||
Common.LogDebug(fmt.Sprintf("指令解析结果: 名称=%s, 标志=%s, 分隔符=%s, 内容=%s",
|
||
directiveName, Flag, delimiter, directiveStr))
|
||
|
||
return directive
|
||
}
|
||
|
||
// 解析探测器信息
|
||
func (p *Probe) parseProbeInfo(probeStr string) {
|
||
Common.LogDebug("开始解析探测器信息，输入字符串: " + probeStr)
|
||
|
||
// 提取协议和其他信息
|
||
proto := probeStr[:4]
|
||
other := probeStr[4:]
|
||
|
||
// 验证协议类型
|
||
if !(proto == "TCP " || proto == "UDP ") {
|
||
errMsg := "探测器协议必须是 TCP 或 UDP"
|
||
Common.LogDebug("错误: " + errMsg)
|
||
panic(errMsg)
|
||
}
|
||
|
||
// 验证其他信息不为空
|
||
if len(other) == 0 {
|
||
errMsg := "nmap-service-probes - 探测器名称无效"
|
||
Common.LogDebug("错误: " + errMsg)
|
||
panic(errMsg)
|
||
}
|
||
|
||
// 解析指令
|
||
directive := p.getDirectiveSyntax(other)
|
||
|
||
// 设置探测器属性
|
||
p.Name = directive.DirectiveName
|
||
p.Data = strings.Split(directive.DirectiveStr, directive.Delimiter)[0]
|
||
p.Protocol = strings.ToLower(strings.TrimSpace(proto))
|
||
|
||
Common.LogDebug(fmt.Sprintf("探测器解析完成: 名称=%s, 数据=%s, 协议=%s",
|
||
p.Name, p.Data, p.Protocol))
|
||
}
|
||
|
||
// 从字符串解析探测器信息
|
||
func (p *Probe) fromString(data string) error {
|
||
Common.LogDebug("开始解析探测器字符串数据")
|
||
var err error
|
||
|
||
// 预处理数据
|
||
data = strings.TrimSpace(data)
|
||
lines := strings.Split(data, "\n")
|
||
if len(lines) == 0 {
|
||
return fmt.Errorf("输入数据为空")
|
||
}
|
||
|
||
probeStr := lines[0]
|
||
p.parseProbeInfo(probeStr)
|
||
|
||
// 解析匹配规则和其他配置
|
||
var matchs []Match
|
||
for _, line := range lines {
|
||
Common.LogDebug("处理行: " + line)
|
||
switch {
|
||
case strings.HasPrefix(line, "match "):
|
||
match, err := p.getMatch(line)
|
||
if err != nil {
|
||
Common.LogDebug("解析match失败: " + err.Error())
|
||
continue
|
||
}
|
||
matchs = append(matchs, match)
|
||
|
||
case strings.HasPrefix(line, "softmatch "):
|
||
softMatch, err := p.getSoftMatch(line)
|
||
if err != nil {
|
||
Common.LogDebug("解析softmatch失败: " + err.Error())
|
||
continue
|
||
}
|
||
matchs = append(matchs, softMatch)
|
||
|
||
case strings.HasPrefix(line, "ports "):
|
||
p.parsePorts(line)
|
||
|
||
case strings.HasPrefix(line, "sslports "):
|
||
p.parseSSLPorts(line)
|
||
|
||
case strings.HasPrefix(line, "totalwaitms "):
|
||
p.parseTotalWaitMS(line)
|
||
|
||
case strings.HasPrefix(line, "tcpwrappedms "):
|
||
p.parseTCPWrappedMS(line)
|
||
|
||
case strings.HasPrefix(line, "rarity "):
|
||
p.parseRarity(line)
|
||
|
||
case strings.HasPrefix(line, "fallback "):
|
||
p.parseFallback(line)
|
||
}
|
||
}
|
||
p.Matchs = &matchs
|
||
Common.LogDebug(fmt.Sprintf("解析完成，共有 %d 个匹配规则", len(matchs)))
|
||
return err
|
||
}
|
||
|
||
// 解析端口配置
|
||
func (p *Probe) parsePorts(data string) {
|
||
p.Ports = data[len("ports")+1:]
|
||
Common.LogDebug("解析端口: " + p.Ports)
|
||
}
|
||
|
||
// 解析SSL端口配置
|
||
func (p *Probe) parseSSLPorts(data string) {
|
||
p.SSLPorts = data[len("sslports")+1:]
|
||
Common.LogDebug("解析SSL端口: " + p.SSLPorts)
|
||
}
|
||
|
||
// 解析总等待时间
|
||
func (p *Probe) parseTotalWaitMS(data string) {
|
||
waitMS, err := strconv.Atoi(strings.TrimSpace(data[len("totalwaitms")+1:]))
|
||
if err != nil {
|
||
Common.LogDebug("解析总等待时间失败: " + err.Error())
|
||
return
|
||
}
|
||
p.TotalWaitMS = waitMS
|
||
Common.LogDebug(fmt.Sprintf("总等待时间: %d ms", waitMS))
|
||
}
|
||
|
||
// 解析TCP包装等待时间
|
||
func (p *Probe) parseTCPWrappedMS(data string) {
|
||
wrappedMS, err := strconv.Atoi(strings.TrimSpace(data[len("tcpwrappedms")+1:]))
|
||
if err != nil {
|
||
Common.LogDebug("解析TCP包装等待时间失败: " + err.Error())
|
||
return
|
||
}
|
||
p.TCPWrappedMS = wrappedMS
|
||
Common.LogDebug(fmt.Sprintf("TCP包装等待时间: %d ms", wrappedMS))
|
||
}
|
||
|
||
// 解析稀有度
|
||
func (p *Probe) parseRarity(data string) {
|
||
rarity, err := strconv.Atoi(strings.TrimSpace(data[len("rarity")+1:]))
|
||
if err != nil {
|
||
Common.LogDebug("解析稀有度失败: " + err.Error())
|
||
return
|
||
}
|
||
p.Rarity = rarity
|
||
Common.LogDebug(fmt.Sprintf("稀有度: %d", rarity))
|
||
}
|
||
|
||
// 解析回退配置
|
||
func (p *Probe) parseFallback(data string) {
|
||
p.Fallback = data[len("fallback")+1:]
|
||
Common.LogDebug("回退配置: " + p.Fallback)
|
||
}
|
||
|
||
// 判断是否为十六进制编码
|
||
func isHexCode(b []byte) bool {
|
||
matchRe := regexp.MustCompile(`\\x[0-9a-fA-F]{2}`)
|
||
return matchRe.Match(b)
|
||
}
|
||
|
||
// 判断是否为八进制编码
|
||
func isOctalCode(b []byte) bool {
|
||
matchRe := regexp.MustCompile(`\\[0-7]{1,3}`)
|
||
return matchRe.Match(b)
|
||
}
|
||
|
||
// 判断是否为结构化转义字符
|
||
func isStructCode(b []byte) bool {
|
||
matchRe := regexp.MustCompile(`\\[aftnrv]`)
|
||
return matchRe.Match(b)
|
||
}
|
||
|
||
// 判断是否为正则表达式特殊字符
|
||
func isReChar(n int64) bool {
|
||
reChars := `.*?+{}()^$|\`
|
||
for _, char := range reChars {
|
||
if n == int64(char) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// 判断是否为其他转义序列
|
||
func isOtherEscapeCode(b []byte) bool {
|
||
matchRe := regexp.MustCompile(`\\[^\\]`)
|
||
return matchRe.Match(b)
|
||
}
|
||
|
||
// 从内容解析探测器规则
|
||
func (v *VScan) parseProbesFromContent(content string) {
|
||
Common.LogDebug("开始解析探测器规则文件内容")
|
||
var probes []Probe
|
||
var lines []string
|
||
|
||
// 过滤注释和空行
|
||
linesTemp := strings.Split(content, "\n")
|
||
for _, lineTemp := range linesTemp {
|
||
lineTemp = strings.TrimSpace(lineTemp)
|
||
if lineTemp == "" || strings.HasPrefix(lineTemp, "#") {
|
||
continue
|
||
}
|
||
lines = append(lines, lineTemp)
|
||
}
|
||
|
||
// 验证文件内容
|
||
if len(lines) == 0 {
|
||
errMsg := "读取nmap-service-probes文件失败: 内容为空"
|
||
Common.LogDebug("错误: " + errMsg)
|
||
panic(errMsg)
|
||
}
|
||
|
||
// 检查Exclude指令
|
||
excludeCount := 0
|
||
for _, line := range lines {
|
||
if strings.HasPrefix(line, "Exclude ") {
|
||
excludeCount++
|
||
}
|
||
if excludeCount > 1 {
|
||
errMsg := "nmap-service-probes文件中只允许有一个Exclude指令"
|
||
Common.LogDebug("错误: " + errMsg)
|
||
panic(errMsg)
|
||
}
|
||
}
|
||
|
||
// 验证第一行格式
|
||
firstLine := lines[0]
|
||
if !(strings.HasPrefix(firstLine, "Exclude ") || strings.HasPrefix(firstLine, "Probe ")) {
|
||
errMsg := "解析错误: 首行必须以\"Probe \"或\"Exclude \"开头"
|
||
Common.LogDebug("错误: " + errMsg)
|
||
panic(errMsg)
|
||
}
|
||
|
||
// 处理Exclude指令
|
||
if excludeCount == 1 {
|
||
v.Exclude = firstLine[len("Exclude")+1:]
|
||
lines = lines[1:]
|
||
Common.LogDebug("解析到Exclude规则: " + v.Exclude)
|
||
}
|
||
|
||
// 合并内容并分割探测器
|
||
content = "\n" + strings.Join(lines, "\n")
|
||
probeParts := strings.Split(content, "\nProbe")[1:]
|
||
|
||
// 解析每个探测器
|
||
for _, probePart := range probeParts {
|
||
probe := Probe{}
|
||
if err := probe.fromString(probePart); err != nil {
|
||
Common.LogDebug(fmt.Sprintf("解析探测器失败: %v", err))
|
||
continue
|
||
}
|
||
probes = append(probes, probe)
|
||
}
|
||
|
||
v.AllProbes = probes
|
||
Common.LogDebug(fmt.Sprintf("成功解析 %d 个探测器规则", len(probes)))
|
||
}
|
||
|
||
// 将探测器转换为名称映射
|
||
func (v *VScan) parseProbesToMapKName() {
|
||
Common.LogDebug("开始构建探测器名称映射")
|
||
v.ProbesMapKName = map[string]Probe{}
|
||
for _, probe := range v.AllProbes {
|
||
v.ProbesMapKName[probe.Name] = probe
|
||
Common.LogDebug("添加探测器映射: " + probe.Name)
|
||
}
|
||
}
|
||
|
||
// 设置使用的探测器
|
||
func (v *VScan) SetusedProbes() {
|
||
Common.LogDebug("开始设置要使用的探测器")
|
||
|
||
for _, probe := range v.AllProbes {
|
||
if strings.ToLower(probe.Protocol) == "tcp" {
|
||
if probe.Name == "SSLSessionReq" {
|
||
Common.LogDebug("跳过 SSLSessionReq 探测器")
|
||
continue
|
||
}
|
||
|
||
v.Probes = append(v.Probes, probe)
|
||
Common.LogDebug("添加TCP探测器: " + probe.Name)
|
||
|
||
// 特殊处理TLS会话请求
|
||
if probe.Name == "TLSSessionReq" {
|
||
sslProbe := v.ProbesMapKName["SSLSessionReq"]
|
||
v.Probes = append(v.Probes, sslProbe)
|
||
Common.LogDebug("为TLSSessionReq添加SSL探测器")
|
||
}
|
||
} else {
|
||
v.UdpProbes = append(v.UdpProbes, probe)
|
||
Common.LogDebug("添加UDP探测器: " + probe.Name)
|
||
}
|
||
}
|
||
|
||
Common.LogDebug(fmt.Sprintf("探测器设置完成，TCP: %d个, UDP: %d个",
|
||
len(v.Probes), len(v.UdpProbes)))
|
||
}
|
||
|
||
// 解析match指令获取匹配规则
|
||
func (p *Probe) getMatch(data string) (match Match, err error) {
|
||
Common.LogDebug("开始解析match指令：" + data)
|
||
match = Match{}
|
||
|
||
// 提取match文本并解析指令语法
|
||
matchText := data[len("match")+1:]
|
||
directive := p.getDirectiveSyntax(matchText)
|
||
|
||
// 分割文本获取pattern和版本信息
|
||
textSplited := strings.Split(directive.DirectiveStr, directive.Delimiter)
|
||
if len(textSplited) == 0 {
|
||
return match, fmt.Errorf("无效的match指令格式")
|
||
}
|
||
|
||
pattern := textSplited[0]
|
||
versionInfo := strings.Join(textSplited[1:], "")
|
||
|
||
// 解码并编译正则表达式
|
||
patternUnescaped, decodeErr := DecodePattern(pattern)
|
||
if decodeErr != nil {
|
||
Common.LogDebug("解码pattern失败: " + decodeErr.Error())
|
||
return match, decodeErr
|
||
}
|
||
|
||
patternUnescapedStr := string([]rune(string(patternUnescaped)))
|
||
patternCompiled, compileErr := regexp.Compile(patternUnescapedStr)
|
||
if compileErr != nil {
|
||
Common.LogDebug("编译正则表达式失败: " + compileErr.Error())
|
||
return match, compileErr
|
||
}
|
||
|
||
// 设置match对象属性
|
||
match.Service = directive.DirectiveName
|
||
match.Pattern = pattern
|
||
match.PatternCompiled = patternCompiled
|
||
match.VersionInfo = versionInfo
|
||
|
||
Common.LogDebug(fmt.Sprintf("解析match成功: 服务=%s, Pattern=%s",
|
||
match.Service, match.Pattern))
|
||
return match, nil
|
||
}
|
||
|
||
// 解析softmatch指令获取软匹配规则
|
||
func (p *Probe) getSoftMatch(data string) (softMatch Match, err error) {
|
||
Common.LogDebug("开始解析softmatch指令：" + data)
|
||
softMatch = Match{IsSoft: true}
|
||
|
||
// 提取softmatch文本并解析指令语法
|
||
matchText := data[len("softmatch")+1:]
|
||
directive := p.getDirectiveSyntax(matchText)
|
||
|
||
// 分割文本获取pattern和版本信息
|
||
textSplited := strings.Split(directive.DirectiveStr, directive.Delimiter)
|
||
if len(textSplited) == 0 {
|
||
return softMatch, fmt.Errorf("无效的softmatch指令格式")
|
||
}
|
||
|
||
pattern := textSplited[0]
|
||
versionInfo := strings.Join(textSplited[1:], "")
|
||
|
||
// 解码并编译正则表达式
|
||
patternUnescaped, decodeErr := DecodePattern(pattern)
|
||
if decodeErr != nil {
|
||
Common.LogDebug("解码pattern失败: " + decodeErr.Error())
|
||
return softMatch, decodeErr
|
||
}
|
||
|
||
patternUnescapedStr := string([]rune(string(patternUnescaped)))
|
||
patternCompiled, compileErr := regexp.Compile(patternUnescapedStr)
|
||
if compileErr != nil {
|
||
Common.LogDebug("编译正则表达式失败: " + compileErr.Error())
|
||
return softMatch, compileErr
|
||
}
|
||
|
||
// 设置softMatch对象属性
|
||
softMatch.Service = directive.DirectiveName
|
||
softMatch.Pattern = pattern
|
||
softMatch.PatternCompiled = patternCompiled
|
||
softMatch.VersionInfo = versionInfo
|
||
|
||
Common.LogDebug(fmt.Sprintf("解析softmatch成功: 服务=%s, Pattern=%s",
|
||
softMatch.Service, softMatch.Pattern))
|
||
return softMatch, nil
|
||
}
|
||
|
||
// 解码模式字符串，处理转义序列
|
||
func DecodePattern(s string) ([]byte, error) {
|
||
Common.LogDebug("开始解码pattern: " + s)
|
||
sByteOrigin := []byte(s)
|
||
|
||
// 处理十六进制、八进制和结构化转义序列
|
||
matchRe := regexp.MustCompile(`\\(x[0-9a-fA-F]{2}|[0-7]{1,3}|[aftnrv])`)
|
||
sByteDec := matchRe.ReplaceAllFunc(sByteOrigin, func(match []byte) (v []byte) {
|
||
var replace []byte
|
||
|
||
// 处理十六进制转义
|
||
if isHexCode(match) {
|
||
hexNum := match[2:]
|
||
byteNum, _ := strconv.ParseInt(string(hexNum), 16, 32)
|
||
if isReChar(byteNum) {
|
||
replace = []byte{'\\', uint8(byteNum)}
|
||
} else {
|
||
replace = []byte{uint8(byteNum)}
|
||
}
|
||
}
|
||
|
||
// 处理结构化转义字符
|
||
if isStructCode(match) {
|
||
structCodeMap := map[int][]byte{
|
||
97: []byte{0x07}, // \a 响铃
|
||
102: []byte{0x0c}, // \f 换页
|
||
116: []byte{0x09}, // \t 制表符
|
||
110: []byte{0x0a}, // \n 换行
|
||
114: []byte{0x0d}, // \r 回车
|
||
118: []byte{0x0b}, // \v 垂直制表符
|
||
}
|
||
replace = structCodeMap[int(match[1])]
|
||
}
|
||
|
||
// 处理八进制转义
|
||
if isOctalCode(match) {
|
||
octalNum := match[2:]
|
||
byteNum, _ := strconv.ParseInt(string(octalNum), 8, 32)
|
||
replace = []byte{uint8(byteNum)}
|
||
}
|
||
return replace
|
||
})
|
||
|
||
// 处理其他转义序列
|
||
matchRe2 := regexp.MustCompile(`\\([^\\])`)
|
||
sByteDec2 := matchRe2.ReplaceAllFunc(sByteDec, func(match []byte) (v []byte) {
|
||
if isOtherEscapeCode(match) {
|
||
return match
|
||
}
|
||
return match
|
||
})
|
||
|
||
Common.LogDebug("pattern解码完成")
|
||
return sByteDec2, nil
|
||
}
|
||
|
||
// ProbesRarity 用于按稀有度排序的探测器切片
|
||
type ProbesRarity []Probe
|
||
|
||
// Len 返回切片长度，实现 sort.Interface 接口
|
||
func (ps ProbesRarity) Len() int {
|
||
return len(ps)
|
||
}
|
||
|
||
// Swap 交换切片中的两个元素，实现 sort.Interface 接口
|
||
func (ps ProbesRarity) Swap(i, j int) {
|
||
ps[i], ps[j] = ps[j], ps[i]
|
||
}
|
||
|
||
// Less 比较函数，按稀有度升序排序，实现 sort.Interface 接口
|
||
func (ps ProbesRarity) Less(i, j int) bool {
|
||
return ps[i].Rarity < ps[j].Rarity
|
||
}
|
||
|
||
// Target 定义目标结构体
|
||
type Target struct {
|
||
IP string // 目标IP地址
|
||
Port int // 目标端口
|
||
Protocol string // 协议类型
|
||
}
|
||
|
||
// ContainsPort 检查指定端口是否在探测器的端口范围内
|
||
func (p *Probe) ContainsPort(testPort int) bool {
|
||
Common.LogDebug(fmt.Sprintf("检查端口 %d 是否在探测器端口范围内: %s", testPort, p.Ports))
|
||
|
||
// 检查单个端口
|
||
ports := strings.Split(p.Ports, ",")
|
||
for _, port := range ports {
|
||
port = strings.TrimSpace(port)
|
||
cmpPort, err := strconv.Atoi(port)
|
||
if err == nil && testPort == cmpPort {
|
||
Common.LogDebug(fmt.Sprintf("端口 %d 匹配单个端口", testPort))
|
||
return true
|
||
}
|
||
}
|
||
|
||
// 检查端口范围
|
||
for _, port := range ports {
|
||
port = strings.TrimSpace(port)
|
||
if strings.Contains(port, "-") {
|
||
portRange := strings.Split(port, "-")
|
||
if len(portRange) != 2 {
|
||
Common.LogDebug("无效的端口范围格式: " + port)
|
||
continue
|
||
}
|
||
|
||
start, err1 := strconv.Atoi(strings.TrimSpace(portRange[0]))
|
||
end, err2 := strconv.Atoi(strings.TrimSpace(portRange[1]))
|
||
|
||
if err1 != nil || err2 != nil {
|
||
Common.LogDebug(fmt.Sprintf("解析端口范围失败: %s", port))
|
||
continue
|
||
}
|
||
|
||
if testPort >= start && testPort <= end {
|
||
Common.LogDebug(fmt.Sprintf("端口 %d 在范围 %d-%d 内", testPort, start, end))
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
|
||
Common.LogDebug(fmt.Sprintf("端口 %d 不在探测器端口范围内", testPort))
|
||
return false
|
||
}
|
||
|
||
// MatchPattern 使用正则表达式匹配响应内容
|
||
func (m *Match) MatchPattern(response []byte) bool {
|
||
// 将响应转换为字符串并进行匹配
|
||
responseStr := string([]rune(string(response)))
|
||
foundItems := m.PatternCompiled.FindStringSubmatch(responseStr)
|
||
|
||
if len(foundItems) > 0 {
|
||
m.FoundItems = foundItems
|
||
Common.LogDebug(fmt.Sprintf("匹配成功，找到 %d 个匹配项", len(foundItems)))
|
||
return true
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
// ParseVersionInfo 解析版本信息并返回额外信息结构
|
||
func (m *Match) ParseVersionInfo(response []byte) Extras {
|
||
Common.LogDebug("开始解析版本信息")
|
||
var extras = Extras{}
|
||
|
||
// 替换版本信息中的占位符
|
||
foundItems := m.FoundItems[1:] // 跳过第一个完整匹配项
|
||
versionInfo := m.VersionInfo
|
||
for index, value := range foundItems {
|
||
dollarName := "$" + strconv.Itoa(index+1)
|
||
versionInfo = strings.Replace(versionInfo, dollarName, value, -1)
|
||
}
|
||
Common.LogDebug("替换后的版本信息: " + versionInfo)
|
||
|
||
// 定义解析函数
|
||
parseField := func(field, pattern string) string {
|
||
patterns := []string{
|
||
pattern + `/([^/]*)/`, // 斜线分隔
|
||
pattern + `\|([^|]*)\|`, // 竖线分隔
|
||
}
|
||
|
||
for _, p := range patterns {
|
||
if strings.Contains(versionInfo, pattern) {
|
||
regex := regexp.MustCompile(p)
|
||
if matches := regex.FindStringSubmatch(versionInfo); len(matches) > 1 {
|
||
Common.LogDebug(fmt.Sprintf("解析到%s: %s", field, matches[1]))
|
||
return matches[1]
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// 解析各个字段
|
||
extras.VendorProduct = parseField("厂商产品", " p")
|
||
extras.Version = parseField("版本", " v")
|
||
extras.Info = parseField("信息", " i")
|
||
extras.Hostname = parseField("主机名", " h")
|
||
extras.OperatingSystem = parseField("操作系统", " o")
|
||
extras.DeviceType = parseField("设备类型", " d")
|
||
|
||
// 特殊处理CPE
|
||
if strings.Contains(versionInfo, " cpe:/") || strings.Contains(versionInfo, " cpe:|") {
|
||
cpePatterns := []string{`cpe:/([^/]*)`, `cpe:\|([^|]*)`}
|
||
for _, pattern := range cpePatterns {
|
||
regex := regexp.MustCompile(pattern)
|
||
if cpeName := regex.FindStringSubmatch(versionInfo); len(cpeName) > 0 {
|
||
if len(cpeName) > 1 {
|
||
extras.CPE = cpeName[1]
|
||
} else {
|
||
extras.CPE = cpeName[0]
|
||
}
|
||
Common.LogDebug("解析到CPE: " + extras.CPE)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
return extras
|
||
}
|
||
|
||
// ToMap 将 Extras 转换为 map[string]string
|
||
func (e *Extras) ToMap() map[string]string {
|
||
Common.LogDebug("开始转换Extras为Map")
|
||
result := make(map[string]string)
|
||
|
||
// 定义字段映射
|
||
fields := map[string]string{
|
||
"vendor_product": e.VendorProduct,
|
||
"version": e.Version,
|
||
"info": e.Info,
|
||
"hostname": e.Hostname,
|
||
"os": e.OperatingSystem,
|
||
"device_type": e.DeviceType,
|
||
"cpe": e.CPE,
|
||
}
|
||
|
||
// 添加非空字段到结果map
|
||
for key, value := range fields {
|
||
if value != "" {
|
||
result[key] = value
|
||
Common.LogDebug(fmt.Sprintf("添加字段 %s: %s", key, value))
|
||
}
|
||
}
|
||
|
||
Common.LogDebug(fmt.Sprintf("转换完成，共有 %d 个字段", len(result)))
|
||
return result
|
||
}
|
||
|
||
func DecodeData(s string) ([]byte, error) {
|
||
if len(s) == 0 {
|
||
Common.LogDebug("输入数据为空")
|
||
return nil, fmt.Errorf("empty input")
|
||
}
|
||
|
||
Common.LogDebug(fmt.Sprintf("开始解码数据，长度: %d, 内容: %q", len(s), s))
|
||
sByteOrigin := []byte(s)
|
||
|
||
// 处理十六进制、八进制和结构化转义序列
|
||
matchRe := regexp.MustCompile(`\\(x[0-9a-fA-F]{2}|[0-7]{1,3}|[aftnrv])`)
|
||
sByteDec := matchRe.ReplaceAllFunc(sByteOrigin, func(match []byte) []byte {
|
||
// 处理十六进制转义
|
||
if isHexCode(match) {
|
||
hexNum := match[2:]
|
||
byteNum, err := strconv.ParseInt(string(hexNum), 16, 32)
|
||
if err != nil {
|
||
return match
|
||
}
|
||
return []byte{uint8(byteNum)}
|
||
}
|
||
|
||
// 处理结构化转义字符
|
||
if isStructCode(match) {
|
||
structCodeMap := map[int][]byte{
|
||
97: []byte{0x07}, // \a 响铃
|
||
102: []byte{0x0c}, // \f 换页
|
||
116: []byte{0x09}, // \t 制表符
|
||
110: []byte{0x0a}, // \n 换行
|
||
114: []byte{0x0d}, // \r 回车
|
||
118: []byte{0x0b}, // \v 垂直制表符
|
||
}
|
||
if replace, ok := structCodeMap[int(match[1])]; ok {
|
||
return replace
|
||
}
|
||
return match
|
||
}
|
||
|
||
// 处理八进制转义
|
||
if isOctalCode(match) {
|
||
octalNum := match[2:]
|
||
byteNum, err := strconv.ParseInt(string(octalNum), 8, 32)
|
||
if err != nil {
|
||
return match
|
||
}
|
||
return []byte{uint8(byteNum)}
|
||
}
|
||
|
||
Common.LogDebug(fmt.Sprintf("无法识别的转义序列: %s", string(match)))
|
||
return match
|
||
})
|
||
|
||
// 处理其他转义序列
|
||
matchRe2 := regexp.MustCompile(`\\([^\\])`)
|
||
sByteDec2 := matchRe2.ReplaceAllFunc(sByteDec, func(match []byte) []byte {
|
||
if len(match) < 2 {
|
||
return match
|
||
}
|
||
if isOtherEscapeCode(match) {
|
||
return []byte{match[1]}
|
||
}
|
||
return match
|
||
})
|
||
|
||
if len(sByteDec2) == 0 {
|
||
Common.LogDebug("解码后数据为空")
|
||
return nil, fmt.Errorf("decoded data is empty")
|
||
}
|
||
|
||
Common.LogDebug(fmt.Sprintf("解码完成，结果长度: %d, 内容: %x", len(sByteDec2), sByteDec2))
|
||
return sByteDec2, nil
|
||
}
|
||
|
||
// GetAddress 获取目标的完整地址（IP:端口）
|
||
func (t *Target) GetAddress() string {
|
||
addr := t.IP + ":" + strconv.Itoa(t.Port)
|
||
Common.LogDebug("获取目标地址: " + addr)
|
||
return addr
|
||
}
|
||
|
||
// trimBanner 处理和清理横幅数据
|
||
func trimBanner(buf []byte) string {
|
||
Common.LogDebug("开始处理横幅数据")
|
||
bufStr := string(buf)
|
||
|
||
// 特殊处理SMB协议
|
||
if strings.Contains(bufStr, "SMB") {
|
||
banner := hex.EncodeToString(buf)
|
||
if len(banner) > 0xa+6 && banner[0xa:0xa+6] == "534d42" { // "SMB" in hex
|
||
Common.LogDebug("检测到SMB协议数据")
|
||
plain := banner[0xa2:]
|
||
data, err := hex.DecodeString(plain)
|
||
if err != nil {
|
||
Common.LogDebug("SMB数据解码失败: " + err.Error())
|
||
return bufStr
|
||
}
|
||
|
||
// 解析domain
|
||
var domain string
|
||
var index int
|
||
for i, s := range data {
|
||
if s != 0 {
|
||
domain += string(s)
|
||
} else if i+1 < len(data) && data[i+1] == 0 {
|
||
index = i + 2
|
||
break
|
||
}
|
||
}
|
||
|
||
// 解析hostname
|
||
var hostname string
|
||
remainData := data[index:]
|
||
for i, h := range remainData {
|
||
if h != 0 {
|
||
hostname += string(h)
|
||
}
|
||
if i+1 < len(remainData) && remainData[i+1] == 0 {
|
||
break
|
||
}
|
||
}
|
||
|
||
smbBanner := fmt.Sprintf("hostname: %s domain: %s", hostname, domain)
|
||
Common.LogDebug("SMB横幅: " + smbBanner)
|
||
return smbBanner
|
||
}
|
||
}
|
||
|
||
// 处理常规数据
|
||
var src string
|
||
for _, ch := range bufStr {
|
||
if ch > 32 && ch < 125 {
|
||
src += string(ch)
|
||
} else {
|
||
src += " "
|
||
}
|
||
}
|
||
|
||
// 清理多余空白
|
||
re := regexp.MustCompile(`\s{2,}`)
|
||
src = re.ReplaceAllString(src, ".")
|
||
result := strings.TrimSpace(src)
|
||
Common.LogDebug("处理后的横幅: " + result)
|
||
return result
|
||
}
|
||
|
||
// Init 初始化VScan对象
|
||
func (v *VScan) Init() {
|
||
Common.LogDebug("开始初始化VScan")
|
||
v.parseProbesFromContent(ProbeString)
|
||
v.parseProbesToMapKName()
|
||
v.SetusedProbes()
|
||
Common.LogDebug("VScan初始化完成")
|
||
}
|