分析某款go端口扫描器之二

一、概述

本次主要分析指纹识别部分，针对开放http的端口的服务信息进行识别。

项目来源：https://github.com/XinRoom/go-portScan/blob/main/util/file.go

二、core--port-fingerprint-webfinger目录

1、fingerprint-webfinger-faviconhash.go

此文件的功能，主要是从html页面中提取favicon的url，然后计算favicon的hash值

此文件中主要包含三个方法：

• func FindFaviconUrl(body string) string

从 HTML 页面的字符串中提取 favicon 的 URL；使用正则表达式 shortcutText 匹配包含 favicon 的 标签，然后再使用 shortcutHref 提取其 href 属性中的 URL

• func mmh3Hash32(raw []byte) string

计算给定字节切片的 MurmurHash3 32 位哈希值；使用 MurmurHash3 算法对输入的字节切片进行哈希运算，返回结果作为字符串表示。

• func standBase64(braw []byte) []byte

对二进制数据进行标准的 Base64 编码，并按行分割。将输入的二进制数据使用标准的 Base64 编码成字符串，然后按照每行字符数为 76 的标准，将编码后的结果分割成多行。

package webfinger

import (
	"bytes"
	"encoding/base64"
	"fmt"
	"github.com/twmb/murmur3"
	"regexp"
)

var (
	shortcutText = regexp.MustCompile(`(?im)`)//提取link标签的正则表达式
	shortcutHref = regexp.MustCompile(`(?im)href=['"]+(.*?)['"]+`)//提取link标签里的href值的正则表达式
)

func FindFaviconUrl(body string) string {
	a := shortcutText.FindStringSubmatch(body)//首先根据正则提取传入的html页面的link标签，赋值给a
	if len(a) > 0 {//如果存在link标签
		faviconLink := a[0]
		b := shortcutHref.FindStringSubmatch(faviconLink)//提取第一个link标签的href的值
		if len(b) > 1 {
			return b[1] //如果提取url成功，则返回url
		}
	}
	return ""//不存在link标签，返回空
}

func mmh3Hash32(raw []byte) string {
	var h32 = murmur3.New32()
	_, err := h32.Write(raw)
	if err == nil {
		return fmt.Sprintf("%d", int32(h32.Sum32()))//使用 MurmurHash3 算法对输入的字节切片进行哈希运算，返回结果作为字符串表示。
	} else {
		return ""
	}
}

func standBase64(braw []byte) []byte {
	bckd := base64.StdEncoding.EncodeToString(braw)
	var buffer bytes.Buffer
	for i := 0; i < len(bckd); i++ {
		ch := bckd[i]
		buffer.WriteByte(ch)
		if (i+1)%76 == 0 {
			buffer.WriteByte('\n')//将输入的二进制数据使用标准的 Base64 编码成字符串，然后按照每行字符数为 76 的标准，将编码后的结果分割成多行。
		}
	}
	buffer.WriteByte('\n')
	return buffer.Bytes()
}

2、fingerprint-webfinger-finger.json

这个文件主要为faviconhash的字典，用来通过faviconhash的值比对来获取指纹信息。

3、fingerprint-webfinger-finger.go

此文件代码是一个 Web 系统指纹识别器。它的主要目的是从 HTTP 响应或 Favicon.ico 数据中识别 Web 服务的指纹。下面是一步步的解释：

• type Date struct
• type WebFinger struct 

Date 结构体表示特定指纹识别方法的数据结构;

WebFinger 结构体用于保存不同的指纹集合

type Date struct {
	Name     string //指纹名称
	Location string  //在http响应中的位置
	Method   string  //指纹识别方法（如keyword、regular、faviconhash）
	Keyword  []string //关键字或者正则表达式数组
}

type WebFinger struct {
	Name    string    //指纹集合的名称
	Fingers []Date    //包含data结构体的切片
}

var WebFingers []WebFinger

//go:embed finger.json
var DefFingerData []byte

• func ParseWebFingerData(data []byte) error

解析 Web 指纹数据。

func ParseWebFingerData(data []byte) error {
    err := json.Unmarshal(data, &WebFingers)  //将json数据保存到WebFingers实例中
    if err != nil {
        return err
    }
    return nil
}

• func LoadWebFingerData(file string) error

从文件中加载 Web 指纹数据。

//LoadWebFingerData 加载web指纹数据
func LoadWebFingerData(file string) error {

    data, err := os.ReadFile(file)
    if err != nil {
        return err
    }
    err = ParseWebFingerData(data)
    if err != nil {
        return err
    }
    return nil
}

• func web FingerIdent(resp *http.Response) (names []string)

此函数解析 HTTP 响应的内容和头部信息，然后遍历 WebFingers 中的指纹集合，检查是否匹配给定的指纹识别方法和关键字或正则表达式；如果匹配，则返回匹配的指纹名称。 

•  解析 HTTP 响应的内容和头部信息。
• 遍历 WebFingers 中的指纹集合，检查是否匹配给定的指纹识别方法和关键字或正则表达式。
• 如果匹配，则返回匹配的指纹名称。

//WebFingerIdent web系统指纹识别 用指纹库的指纹循环比对response中header部分和body部分是否包含特征
func WebFingerIdent(resp *http.Response) (names []string){
    var dataMap = make(map[string]string)
    body, _ := io.ReadAll(resp.Body)
    dataMap["body"] = string(body)
    var b bytes.Buffer
    resp.Header.Write(&b)
    dataMap["header"] = b.String()
    for _,finger :=  range WebFingers {
        for _, finger2 := range finger.Fingers {
            var flag bool
            if _, ok := dataMap[finger2.Location]; !ok {//取指纹库中Location字段为body和header部分的指纹
                continue
            }
            switch finger2.Method {
                case "keyword" :
                    if iskeyword(dataMap[finger2.Location], finger2.Keyword){
                        flag = true
                    }
                case "regular" :
                    if isregular(dataMap[finger2.Location], finger2.Keyword){
                        flag = true
                    }
            }
            if flag {
                if finger2.Name != ""{
                    finger.Name += "," + finger2.Name
                }
                names = append(names, finger.Name)
                break
            }
        }
    }
    return
    
}

• func WebFingerIdentByFavicon(body []byte) (names []string)

 此函数通过 Favicon.ico 识别 Web 系统的指纹。首先对对 Favicon.ico 数据进行哈希运算，然后遍历WebFingers 中的指纹集合，检查是否与哈希值匹配指定的指纹识别方法和关键字。如果匹配，则返回匹配的指纹名称。

• 对 Favicon.ico 数据进行哈希运算。
• 遍历 WebFingers 中的指纹集合，检查是否与哈希值匹配指定的指纹识别方法和关键字。
• 如果匹配，则返回匹配的指纹名称。

// WebFingerIdentByFavicon web系统指纹识别,通过Favicon.ico用指纹库的指纹循环比对favico hash之判断是否包含特征
func WebFingerIdentByFavicon(body []byte) (names []string) {
	var data string
	data = mmh3Hash32(standBase64(body))
	for _, finger := range WebFingers {
		for _, finger2 := range finger.Fingers {
			switch finger2.Method {
			case "faviconhash":
				if data != "" && len(finger2.Keyword) > 0 && data == finger2.Keyword[0] {
					if finger2.Name != "" {
						finger.Name += "," + finger2.Name
					}
					names = append(names, finger.Name)
					break
				}
			}
		}
	}
	return
}

4、fingerprint-webfinger-matchfinger.go

此文件包含两个方法，iskeyword和isregular，都是用于检查字符串中是否存在特定的关键字或匹配正则表达式

• func iskeyword(str string, keyword []string) bool

检查字符串中是否存在指定的关键字。遍历关键字数组，如果字符串中不包含其中任何一个关键字，则立即返回 false，否则返回 true。

• func isregular(str string, keyword []string) bool

检查字符串是否匹配指定的正则表达式。遍历正则表达式数组，使用 regexp.MustCompile 创建正则表达式对象，然后检查字符串是否与每个正则表达式匹配。如果字符串不匹配任何一个正则表达式，则立即返回 false，否则返回 true。

func iskeyword(str string, keyword []string) bool {
	if len(keyword) == 0 || str == "" {//先判断传入关键字切片是否为空和字符串是否为空
		return false
	}
    //遍历关键字数组，如果字符串中不包含其中任何一个关键字，则立即返回 
	for _, k := range keyword {//循环遍历keyword切片，检查keyword是否都包含在str字符串中
		if !strings.Contains(str, k) {
			return false
		}
	}
	return true
}

//遍历正则表达式数组，使用 regexp.MustCompile 创建正则表达式对象，然后检查字符串是否与每个正则表达式匹配。如果字符串不匹配任何一个正则表达式，则立即返回 false，否则返回 true。
func isregular(str string, keyword []string) bool {
	if len(keyword) == 0 || str == "" {
		return false
	}
	for _, k := range keyword {
		re := regexp.MustCompile(k)
		if !re.Match([]byte(str)) {
			return false
		}
	}
	return true
}

5、辅助函数

• mmh3Hash32(raw []byte) string：对数据进行哈希并返回哈希值的字符串表示形式。
• standBase64(braw []byte) []byte：对数据进行 Base64 编码，并在每行末尾添加换行符。

三、core-port-fingerprint目录

1、core-port-fingerprint-encodings.go

此文件主要是一些用于字符编码转换的函数，以及一个用于从http响应中提取标题并根据响应的内容类型进行相应的解码的函数。

• func Decodegbk(s []byte) ([]byte, error)

这个函数用于将 GBK 编码的字节序列转换为 UTF-8 编码的字节序列。它使用 simplifiedchinese.GBK.NewDecoder() 进行解码，将输入的 GBK 编码字节流转换为 UTF-8 编码

//将GBK编码转化UTF-编码
func Decodegbk(s []byte) ([]byte, error){
    I := bytes.NewReader(s)
    O := transform.NewReader(I, simplifiedchinese.GBK.NewDecoder())
    d, e := ioutil.ReadAll(O)
    if e != nil {
        return nil, e
    }
    return d, nil

}

• func Decodebig5(s []byte) ([]byte, error)

类似于 Decodegbk，这个函数将 BIG5 编码的字节序列转换为 UTF-8 编码的字节序列，使用 traditionalchinese.Big5.NewDecoder() 进行解码。

func Decodebig5(s []byte) ([]byte, error){
    I := bytes.NewReader(s)
    O := transform.NewReader(I, traditionalchinese.Big5.NewDecoder())
    d, e := ioutil.ReadAll(O)
    if e != nil {
        return nil, e
    }
    return d, nil
}

• func Encodebig5(s []byte) ([]byte, error)

这个函数是将 UTF-8 编码的字节序列转换为 BIG5 编码的字节序列，使用 traditionalchinese.Big5.NewEncoder() 进行编码。

func Encodebig5(s []byte) ([]byte, error){
    I := bytes.NewReader(s)
    O := transform.NewReader(I, traditionalchinese.Big5.NewEncoder())
    d, e := ioutil.ReadAll(O)
    if e != nil {
        return nil, e 
    }
    return d,nil
}

• func DecodeKorean(s []byte) ([]byte, error)

这个函数是用于将韩文编码的字节序列转换为 UTF-8 编码的字节序列，使用 korean.EUCKR.NewDecoder() 进行解码。

func DecodeKorean(s []byte) ([]byte, error) {
    koreanDecoder := korean.EUCKR.NewDecoder()
    return koreanDecoder.Bytes(s)
}

• func DecodeData(data []byte, headers http.Header) ([]byte, error)

这个函数从 HTTP 响应中提取数据，并根据响应的内容类型进行相应的解码。它会检查响应头中的 Content-Type，尝试根据特定的字符集（如 GBK、EUC-KR 等）对数据进行解码。如果检测到响应头中指定了字符集，会调用相应的解码函数进行转换，如果没有匹配到特定的字符集，就会尝试从 HTML 头部的 meta 标签中提取字符集信息，并根据提取的信息进行解码。最终返回解码后的数据或原始数据（如果未指定字符集或解码失败）。

func DecodeData(data []byte, headers http.Header) ([]byte, error) {

    //Non UTF-8
    if contentTypes, ok := headers["Content-Type"]; ok {
        contentType := strings.ToLower(strings.Join(contentTypes, ";"))//用；连接contenttypes内容，并转化为小写
        
        //根据不同的contentyps值调用不同的解密方法
        switch {
            case stringsutil.ContainsAny(contentType, "charset=gb2312","charset=gbk"):
                return Decodegbk([]byte(data))

            case stringsutil.ContainsAyn(contentType,"euc-kr"):
                return DecodeDorean(data)    
        }
        
        //Content-Type 来自 head tag
        var match = reContentType.FindSubmatch(data)//reContentType来自 core/port/fingerprint/title.go ，作用为regexp.MustCompile(`(?im)\s*charset="(.*?)"|charset=(.*?)"\s*`)，根据正则提取对应字段
        var mcontentType = ""
        if len(match) != 0 {
            for i, v := range match{
                if string(v) != "" && i != 0 {
                    mcontentType = string(v)
                }
            }
            mcontentType = strings.ToLower(mcontentType)
        }
        switch {
            case stringsutil.ContainsAny(mcontentType, "gb2312", "gbk"):
                return Decodegbk(data)
        }
    }
    return data, nil
        
}    

ps:这些函数的作用在于根据不同的字符编码格式，将原始的字符序列转换为 UTF-8 编码的字符序列，使其能够被正确解析和处理。DecodeData 函数则是根据 HTTP 响应的内容类型来判断使用何种字符编码转换函数，以确保正确地解码数据

2、core-port-fingerprint-fingerprint.go

这个文件主要用于端口服务的指纹识别，主要功能如下：

首先创建常量和类型：

type Action uint8

const (
	ActionRecv = Action(iota)
	ActionSend
)

const (
	refusedStr   = "refused"
	ioTimeoutStr = "i/o timeout"
)

type ruleData struct {
	Action  Action // send or recv
	Data    []byte // send or match data
	Regexps []*regexp.Regexp
}

type serviceRule struct {
	Tls       bool
	DataGroup []ruleData
}

var serviceRules = make(map[string]serviceRule)
var readBufPool = &sync.Pool{
	New: func() interface{} {
		return make([]byte, 4096)
	},
}

函数如下：

• func PortIdentify(network string, ip net.IP, _port uint16, dailTimeout time.Duration) (serviceName string, isDailErr bool)

此函数识别端口对应的服务。它按照指定的顺序尝试从一系列服务规则中匹配出对应的服务。如果连接失败或者无法匹配出服务，则返回"unknown"

// PortIdentify 端口识别
func PortIdentify(network string, ip net.IP, _port uint16, dailTimeout time.Duration) (serviceName string, isDailErr bool) {

	matchedRule := make(map[string]struct{})

	unknown := "unknown"
	var matchStatus int

	// 优先判断port可能的服务
	if serviceNames, ok := portServiceOrder[_port]; ok {//portServiceOrder为rule.go文件中常见端口服务对应列表
		for _, service := range serviceNames {
			matchedRule[service] = struct{}{}
			matchStatus = matchRule(network, ip, _port, serviceRules[service], dailTimeout)//获取服务端口开放状态
			if matchStatus == 1 {
				return service, false
			} else if matchStatus == -1 {
				return unknown, true
			}
		}
	}

	// onlyRecv
	{
		var conn net.Conn
		var n int
		buf := readBufPool.Get().([]byte)
		defer func() {
			readBufPool.Put(buf)
		}()
		address := fmt.Sprintf("%s:%d", ip, _port)
		conn, _ = net.DialTimeout(network, address, dailTimeout)
		if conn == nil {
			return unknown, true
		}
		n, _ = read(conn, buf)
		conn.Close()
		if n != 0 {
			for _, service := range onlyRecv {
				_, ok := matchedRule[service] //检测是不是已有服务
				if ok {
					continue
				}
				matchStatus = matchRuleWhithBuf(buf[:n], ip, _port, serviceRules[service])//判断端口服务开放状态
				if matchStatus == 1 {
					return service, false
				}
			}
		}
		for _, service := range onlyRecv {
			matchedRule[service] = struct{}{}
		}
	}

	// 优先判断Top服务
	for _, service := range serviceOrder {
		_, ok := matchedRule[service]
		if ok {
			continue
		}
		matchedRule[service] = struct{}{}
		matchStatus = matchRule(network, ip, _port, serviceRules[service], dailTimeout)
		if matchStatus == 1 {
			return service, false
		} else if matchStatus == -1 {
			return unknown, true
		}
	}

	// other
	for service, rule := range serviceRules {
		_, ok := matchedRule[service]
		if ok {
			continue
		}
		matchStatus = matchRule(network, ip, _port, rule, dailTimeout)
		if matchStatus == 1 {
			return service, false
		} else if matchStatus == -1 {
			return unknown, true
		}
	}

	return unknown, false
}

• func matchRuleWhithBuf(buf, ip net.IP, _port uint16, serviceRule serviceRule) int

函数根据传入的数据缓冲区，匹配给定的服务规则。如果规则中的数据在缓冲区中找到了匹配，则返回成功状态。

// 指纹匹配函数
func matchRuleWhithBuf(buf, ip net.IP, _port uint16, serviceRule serviceRule) int {
	data := []byte("")
	// 逐个判断
	for _, rule := range serviceRule.DataGroup {
		if rule.Data != nil {//先替换请求中的数据data数据，比如IP和port
			data = bytes.Replace(rule.Data, []byte("{IP}"), []byte(ip.String()), -1)
			data = bytes.Replace(data, []byte("{PORT}"), []byte(strconv.Itoa(int(_port))), -1)
		}
		// 包含数据就正确，使用正则匹配
		if rule.Regexps != nil {
			for _, _regex := range rule.Regexps {
				if _regex.MatchString(convert2utf8(string(buf))) {
					return 1
				}
			}
		}
		if bytes.Compare(data, []byte("")) != 0 && bytes.Contains(buf, data) {
			return 1
		}
	}
	return 0
}

• func matchRule(network string, ip net.IP, _port uint16, serviceRule serviceRule, dailTimeout time.Duration) int

此函数建立连接并根据连接的情况进行数据的发送和接收，然后匹配给定的服务规则。如果规则中的数据在接收的数据中找到了匹配，则返回成功状态。

// 指纹匹配函数
func matchRule(network string, ip net.IP, _port uint16, serviceRule serviceRule, dailTimeout time.Duration) int {
	var err error
	var isTls bool
	var conn net.Conn
	var connTls *tls.Conn

	address := fmt.Sprintf("%s:%d", ip, _port)

	// 建立连接
	if serviceRule.Tls {//先确定是不是https
		// tls
		connTls, err = tls.DialWithDialer(&net.Dialer{Timeout: dailTimeout}, network, address, &tls.Config{
			InsecureSkipVerify: true,
			MinVersion:         tls.VersionTLS10,
		})
		if err != nil {
			if strings.HasSuffix(err.Error(), ioTimeoutStr) || strings.Contains(err.Error(), refusedStr) {
				return -1
			}
			return 0
		}
		defer connTls.Close()
		isTls = true
	} else {//如果不是https，使用net.conn连接
		conn, err = net.DialTimeout(network, address, dailTimeout)
		if conn == nil {
			return -1
		}
		defer conn.Close()
	}

	buf := readBufPool.Get().([]byte)
	defer func() {
		readBufPool.Put(buf)
	}()

	data := []byte("")
	// 逐个判断
	for _, rule := range serviceRule.DataGroup {
		if rule.Data != nil {//替换所有data数据中的IP和port，针对http和https
			data = bytes.Replace(rule.Data, []byte("{IP}"), []byte(ip.String()), -1)
			data = bytes.Replace(data, []byte("{PORT}"), []byte(strconv.Itoa(int(_port))), -1)
		}

		if rule.Action == ActionSend {//先判断获取发送数据，进行conn连接
			if isTls {
				connTls.SetWriteDeadline(time.Now().Add(time.Second))
				_, err = connTls.Write(data)
			} else {
				conn.SetWriteDeadline(time.Now().Add(time.Second))
				_, err = conn.Write(data)
			}
			if err != nil {
				// 出错就退出
				return 0
			}
		} else {//针对recive进行数据判断
			var n int
			if isTls {
				n, err = read(connTls, buf)
			} else {
				n, err = read(conn, buf)
			}
			// 出错就退出
			if n == 0 {
				return 0
			}
			// 包含数据就正确  使用正则筛选返回包数据
			if rule.Regexps != nil {
				for _, _regex := range rule.Regexps {
					if _regex.MatchString(convert2utf8(string(buf[:n]))) {
						return 1
					}
				}
			}
            //判断数据是否为空，以及buf中是否包含数据
			if bytes.Compare(data, []byte("")) != 0 && bytes.Contains(buf[:n], data) {
				return 1
			}
		}
	}

	return 0
}

• func read(conn interface{}, buf []byte) (int, error)

函数负责从连接中读取数据，并在指定时间内设置读取的截止时间。它会尝试从传入的连接中读取数据到缓冲区中，并返回读取的字节数和可能出现的错误。如果读取的数据长度为 0 或者发生错误，则会返回相应的状态信息。

func read(conn interface{}, buf []byte) (int, error) {
	switch conn.(type) {
	case net.Conn:
		conn.(net.Conn).SetReadDeadline(time.Now().Add(time.Second))
		return conn.(net.Conn).Read(buf[:])
	case *tls.Conn:
		conn.(*tls.Conn).SetReadDeadline(time.Now().Add(time.Second))
		return conn.(*tls.Conn).Read(buf[:])
	}
	return 0, errors.New("unknown type")
}

• func convert2utf8(src string) string

函数用于修复正则表达式在匹配非UTF-8字符时可能出现的问题。它会将UTF-8以外的字符转换成对应的UTF-8字符，确保正则表达式可以正确匹配。

func convert2utf8(src string) string {
	var dst string
	for i, r := range src {
		var v string
		if r == utf8.RuneError {
			// convert, rune => string, intstring() => encoderune()
			v = string(src[i])
		} else {
			v = string(r)
		}
		dst += v
	}
	return dst
}

 ps：代码中利用 sync.Pool 作为缓冲池，用来存储读取数据的缓冲区，提高效率。总体来说，这些函数实现了通过发送和接收数据并根据特定规则匹配服务的功能，用于识别特定端口上可能运行的服务

3、core-port-fingerprint-rules.go

这个文件主要为一个指纹识别器，它尝试根据不同服务的特征来判断特定端口上的服务。这里的 serviceOrder 是服务的顺序列表，onlyRecv 是仅接收数据的服务列表，portServiceOrder 是特定端口和服务的映射关系。

var serviceOrder = []string{"http", "https", "ssh", "redis", "mysql"}

var onlyRecv []string

var portServiceOrder = map[uint16][]string{
	21:    {"ftp"},
	22:    {"ssh"},
	80:    {"http", "https"},
	443:   {"https", "http"},
	445:   {"smb"},
	1035:  {"oracle"},
	1080:  {"socks5", "socks4"},
	1081:  {"socks5", "socks4"},
	1082:  {"socks5", "socks4"},
	1083:  {"socks5", "socks4"},
	1433:  {"sqlserver"},
	1521:  {"oracle"},
	1522:  {"oracle"},
	1525:  {"oracle"},
	1526:  {"oracle"},
	1574:  {"oracle"},
	1748:  {"oracle"},
	1754:  {"oracle"},
	3306:  {"mysql"},
	3389:  {"ms-wbt-server"},
	6379:  {"redis"},
	9001:  {"mongodb"},
	11211: {"memcached"},
	14238: {"oracle"},
	27017: {"mongodb"},
	20000: {"oracle"},
	49153: {"mongodb"},
}

• func init()

init() 函数中，为了不同的服务（如HTTP、HTTPS、SSH等），定义了对应的识别规则。每个服务都有其特定的数据发送和接收规则，用于匹配返回的数据以确定服务是否存在。例如，对于 HTTP 服务，它尝试发送一个 HTTP 头部，并尝试匹配返回数据中是否包含 HTTP/；对于 SSH 服务，它会尝试匹配返回数据中是否包含 SSH 相关的标识等。这些规则都是通过发送特定数据和匹配接收到的数据来进行识别的

func init() {
    
	// http
	serviceRules["http"] = serviceRule{ //pingerprint.go中结构体，包含Tls和DataGroup
		Tls: false,
		DataGroup: []ruleData{
			{//设置http和https的规则数据，包含请求头和接收包
				ActionSend,
				[]byte("HEAD / HTTP/1.1\r\nHost: {IP}\r\nUser-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0\r\nAccept: */*\r\nAccept-Language: en\r\nAccept-Encoding: deflate\r\n\r\n"),
				nil,
			},
			{
				ActionRecv,
				[]byte("HTTP/"),
				nil,
			},
		},
	}
	// https
	serviceRules["https"] = serviceRule{
		Tls:       true,
		DataGroup: serviceRules["http"].DataGroup,
	}

	// ssh
	serviceRules["ssh"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{//设置ssh的匹配规则
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`^SSH-([\d.]+)-`),
					regexp.MustCompile(`^SSH-(\d[\d.]+)-`),
					regexp.MustCompile(`^SSH-(\d[\d.]*)-`),
					regexp.MustCompile(`^SSH-2\.0-`),
					regexp.MustCompile(`^SSH-1\.`),
				},
			},
		},
	}

	// ftp
	serviceRules["ftp"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{//设置ftp的匹配规则
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`^220 ([-/.+\w]+) FTP server`),
					regexp.MustCompile(`^220[ |-](.*?)FileZilla`),
					regexp.MustCompile(`^(?i)220[ |-](.*?)version`),
					regexp.MustCompile(`^220 3Com `),
					regexp.MustCompile(`^220-GuildFTPd`),
					regexp.MustCompile(`^220-.*\r\n220`),
					regexp.MustCompile(`^220 Internet Rex`),
					regexp.MustCompile(`^530 Connection refused,`),
					regexp.MustCompile(`^220 IIS ([\w._-]+) FTP`),
					regexp.MustCompile(`^220 PizzaSwitch `),
					regexp.MustCompile(`(?i)^220 ([-.+\w]+) FTP`),
					regexp.MustCompile(`(?i)^220[ |-](.*?)FTP`),
				},
			},
		},
	}

	// socks4
	serviceRules["socks4"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{//设置socks4发送包的数据部分
				ActionSend,
				[]byte("\x04\x01\x00\x16\x7f\x00\x00\x01rooo\x00"),
				nil,
			},
			{//设置socks4接收包的匹配规则
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`^\x00\x5a`),
					regexp.MustCompile(`^\x00\x5b`),
					regexp.MustCompile(`^\x00\x5c`),
					regexp.MustCompile(`^\x00\x5d`),
				},
			},
		},
	}

	// socks5
	serviceRules["socks5"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{//设置socks5的发送包数据
				ActionSend,
				[]byte("\x05\x04\x00\x01\x02\x80\x05\x01\x00\x03\x0dwww.baidu.com\x00\x50GET / HTTP/1.0\r\n\r\n"),
				nil,
			},
			{//设置socks5的接收包规则
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`^\x05\x00\x05\x01`),
					regexp.MustCompile(`^\x05\x00\x05\x00\x00\x01.{6}HTTP`),
					regexp.MustCompile(`^\x05\x02`),
					regexp.MustCompile(`^\x05\x00`),
				},
			},
		},
	}

	 tls
	//serviceRules["tls"] = serviceRule{
	//	Tls: false,
	//	DataGroup: []ruleData{
	//		{
	//			ActionSend,
	//			[]byte("\x16\x03\x00\x00S\x01\x00\x00O\x03\x00?G\xd7\xf7\xba,\xee\xea\xb2`~\xf3\x00\xfd\x82{\xb9\xd5\x96\xc8w\x9b\xe6\xc4\xdb<=\xdbo\xef\x10n\x00\x00(\x00\x16\x00\x13\x00\x0a\x00f\x00\x05\x00\x04\x00e\x00d\x00c\x00b\x00a\x00`\x00\x15\x00\x12\x00\x09\x00\x14\x00\x11\x00\x08\x00\x06\x00\x03\x01\x00"),
	//			nil,
	//		},
	//		{
	//			ActionRecv,
	//			nil,
	//			[]*regexp.Regexp{
	//				regexp.MustCompile(`^[\x16\x15]\x03\x00`),
	//				regexp.MustCompile(`^[\x16\x15]\x03...\x02`),
	//			},
	//		},
	//	},
	//}

	// smb
	serviceRules["smb"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{//设置smb协议的发送包数据
				ActionSend,
				[]byte("\x00\x00\x00\xa4\xff\x53\x4d\x42\x72\x00\x00\x00\x00\x08\x01\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x06\x00\x00\x01\x00\x00\x81\x00\x02PC NETWORK PROGRAM 1.0\x00\x02MICROSOFT NETWORKS 1.03\x00\x02MICROSOFT NETWORKS 3.0\x00\x02LANMAN1.0\x00\x02LM1.2X002\x00\x02Samba\x00\x02NT LM 0.12\x00\x02NT LANMAN 1.0\x00"),
				nil,
			},
			{//设置smb协议的接收包规则
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`MBr\x00\x00\x00\x00\x88\x01@\x00`),
				},
			},
		},
	}

	// ms-wbt-server
	serviceRules["ms-wbt-server"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionSend,
				[]byte("\x03\x00\x00*%\xe0\x00\x00\x00\x00\x00Cookie: mstshash=pcpc\r\n\x01\x00\x08\x00\x03\x00\x00\x00"),
				nil,
			},
			{
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`\x03\x00\x00.\x0e\xd0\x00\x00\x124\x00`),
				},
			},
		},
	}

	// jdwp
	serviceRules["jdwp"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionRecv,
				[]byte("JDWP-Handshake"),
				nil,
			},
		},
	}

	// jdbc
	serviceRules["jdbc"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionRecv,
				[]byte("HSQLDB JDBC Network Listener"),
				nil,
			},
		},
	}

	// Db
	// mysql
	serviceRules["mysql"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`(?s)^.\x00\x00\x00\xff..Host .* is not allowed to connect to this .* server$`),
					regexp.MustCompile(`^.\x00\x00\x00\xff..Too many connections`),
					regexp.MustCompile(`(?s)^.\x00\x00\x00\xff..Host .* is blocked because of many connection errors`),
					regexp.MustCompile(`(?s)^.\x00\x00\x00\x0a(\d\.[-_~.+:\w]+MariaDB-[-_~.+:\w]+)`),
					regexp.MustCompile(`(?s)^.\x00\x00\x00\x0a(\d\.[-_~.+\w]+)\x00`),
					regexp.MustCompile(`(?s)^.\x00\x00\x00\xffj\x04'[\d.]+' .* MySQL`),
				},
			},
		},
	}
	// redis
	serviceRules["redis"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionSend,
				[]byte("GET / HTTP/1.1\r\n"),
				nil,
			},
			{
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`-ERR operation not permitted\r\n`),
					regexp.MustCompile(`-ERR wrong number of arguments for 'get' command\r\n`),
				},
			},
		},
	}

	// sqlserver
	serviceRules["sqlserver"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionSend,
				[]byte("\x12\x01\x00\x34\x00\x00\x00\x00\x00\x00\x15\x00\x06\x01\x00\x1b\x00\x01\x02\x00\x1c\x00\x0c\x03\x00\x28\x00\x04\xff\x08\x00\x01\x55\x00\x00\x00\x4d\x53\x53\x51\x4c\x53\x65\x72\x76\x65\x72\x00\x48\x0f\x00\x00"),
				nil,
			},
			{
				ActionRecv,
				[]byte("\x04\x01\x00\x25\x00\x00\x01\x00\x00\x00\x15\x00\x06\x01\x00\x1b\x00\x01\x02\x00\x1c\x00\x01\x03\x00\x1d\x00\x00\xff"),
				nil,
			},
		},
	}

	// oracle
	serviceRules["oracle"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionSend,
				[]byte("\x00Z\x00\x00\x01\x00\x00\x00\x016\x01,\x00\x00\x08\x00\x7F\xFF\x7F\x08\x00\x00\x00\x01\x00 \x00:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x004\xE6\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00(CONNECT_DATA=(COMMAND=version))"),
				nil,
			},
			{
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`(?s)^\x00\x20\x00\x00\x02\x00\x00\x00\x016\x00\x00\x08\x00\x7f\xff\x01\x00\x00\x00\x00\x20`),
					regexp.MustCompile(`^\+\x00\x00\x00$`),
					regexp.MustCompile(`^\x00.\x00\x00\x02\x00\x00\x00.*\(IAGENT`),
					regexp.MustCompile(`^..\x00\x00\x04\x00\x00\x00"\x00..\(DESCRIPTION=`),
					regexp.MustCompile(`^\x00.\x00\x00[\x02\x04]\x00\x00\x00.*\(`),
					regexp.MustCompile(`^\x00.\x00\x00[\x02\x04]\x00\x00\x00.*TNSLSNR`),
					regexp.MustCompile(`^\x00,\x00\x00\x04\x00\x00"`),
				},
			},
		},
	}

	// mongodb
	serviceRules["mongodb"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionSend,
				[]byte("\x41\x00\x00\x00\x3a\x30\x00\x00\xff\xff\xff\xff\xd4\x07\x00\x00\x00\x00\x00\x00test.$cmd\x00\x00\x00\x00\x00\xff\xff\xff\xff\x1b\x00\x00\x00\x01serverStatus\x00\x00\x00\x00\x00\x00\x00\xf0\x3f\x00"),
				nil,
			},
			{
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`(?s)^.*version([: "]+)([.\d]+)"`),
					regexp.MustCompile(`(?s)^\xcb\x00\x00\x00....:0\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\xa7\x00\x00\x00\x01uptime\x00\x00\x00\x00\x00\x00 ` + "`" + `@\x03globalLock\x009\x00\x00\x00\x01totalTime\x00\x00\x00\x00\x7c\xf0\x9a\x9eA\x01lockTime\x00\x00\x00\x00\x00\x00\xac\x9e@\x01ratio\x00!\xc6\$G\xeb\x08\xf0>\x00\x03mem\x00<\x00\x00\x00\x10resident\x00\x03\x00\x00\x00\x10virtual\x00\xa2\x00\x00\x00\x08supported\x00\x01\x12mapped\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01ok\x00\x00\x00\x00\x00\x00\x00\xf0\?\x00$`),
					regexp.MustCompile(`(?s)^.\x00\x00\x00....:0\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\+\x00\x00\x00\x02errmsg\x00\x0e\x00\x00\x00need to login\x00\x01ok\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`),
					regexp.MustCompile(`(?s)^.\x00\x00\x00....:0\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00.\x00\x00\x00\x01ok\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02errmsg\x00.\x00\x00\x00not authorized on`),
				},
			},
		},
	}

	// memcached
	serviceRules["memcached"] = serviceRule{
		Tls: false,
		DataGroup: []ruleData{
			{
				ActionSend,
				[]byte("stats\\n"),
				nil,
			},
			{
				ActionRecv,
				nil,
				[]*regexp.Regexp{
					regexp.MustCompile(`(?s)^STAT pid \d`),
					regexp.MustCompile(`(?s)^ERROR\r\n`),
				},
			},
		},
	}

	// onlyRecv 仅接收数据的服务列表
	for k, m := range serviceRules {
		if len(m.DataGroup) == 1 {
			onlyRecv = append(onlyRecv, k)
		}
	}
}

 ps：总体来说，这个代码段通过发送特定数据并检查返回数据中是否包含特定标识来识别不同服务的存在。如果匹配成功，则确定该服务在特定端口上运行。

4、core-port-fingerprint-title.go

此文件主要处理从 HTML 文档中提取标题以及获取页面重定向的目标 URL。

首先：定义变量，设置获取title、contenttype、refresh、replace的正则

var (
	cutset        = "\n\t\v\f\r"
	reTitle       = regexp.MustCompile(`(?im)<\s*title.*>(.*?)<\s*/\s*title>`)
	reContentType = regexp.MustCompile(`(?im)\s*charset="(.*?)"|charset=(.*?)"\s*`)
	reRefresh     = regexp.MustCompile(`(?im)\s*content=['"]\d;url=['"](.*?)['"]`)
	reReplace     = regexp.MustCompile(`(?im)window\.location\.replace\(['"](.*?)['"]\)`)
)

• func ExtractTitle(body []byte) (title string)

这个函数用于从 HTML 页面中提取标题。它首先尝试使用 DOM 解析器解析文档，并提取其中的标题。如果解析出错，就使用正则表达式 reTitle 在 HTML 文档中查找标题标签，提取标题内容。最后对提取到的标题进行处理，去除空白字符和特殊符号

func ExtractTitle(body []byte) (title string) {
    //先从dom中获取
    titleDom, err := getTitleWithDom(body)//从dom节点中获取title
    //如果出错，则回退到用正则匹配
    if  err != nil {
        for _, match := range reTitle.FindAllString(string(body), -1) {
            title = match
            break
        }
    }else {
        title = renderNode(titleDom)//将html转换为字符串类型
    }
    title = html.UnescapeString(trimTitleTags(title))

    //删除多余字符
    title = strings.TrimSpace(strings.Trim(title, cutset)) //去掉首尾的特殊字符
    title = strings.ReplaceAll(title, "\n", "")
    title = strings.ReplaceAll(title, "\r", "")
    
    return title
}

• func getTitleWithDom(body []byte) (*html.Node, error)

这个函数尝试使用 HTML 解析器来解析 HTML 文档，并找到