go中网络流量分析gopacket库的使用

最新推荐文章于 2024-08-07 09:51:58 发布

dayouziei

最新推荐文章于 2024-08-07 09:51:58 发布

阅读量1k

点赞数

分类专栏： golang 文章标签：服务器网络运维 golang 开发语言

本文链接：https://blog.csdn.net/youuzi/article/details/134059230

版权

golang 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

一、前言

近来，笔者想学习下用go构造tcp数据包，这里涉及到gopacket库的使用，故这里记录下关于gopacket库的一些学习记录

二、介绍

gopacket 是 Go 语言的网络数据包处理库，它提供了方便的 API 来读取、分析、修改和生成网络数据包。你可以使用这个库来修改数据包内容，以实现特定的网络测试或安全目的。

修改数据包的过程大致如下：

使用 gopacket 读取数据包并解码为特定协议的数据结构（如 IP、TCP 等）。
修改相应的字段，如源 IP 地址、目的 IP 地址、源端口、目的端口等。
将数据包编码为原始字节流并写回网络。

通过 gopacket 库可以很方便地实现数据包的修改。

三、使用

加载：go get -u github.com/google/gopacket

1、枚举所有网络设备

func GetAllDevs() {
	//获取所有设备信息
	devices, err := pcap.FindAllDevs()
	if err != nil {
		log.Fatal(err)
	}
	//打印设备信息
	fmt.Println("找到的Devices 信息：")
	for _, device := range devices {
		fmt.Println("\n名字：", device.Name)
		fmt.Println("描述信息：", device.Description)
		fmt.Println("Devices 地址信息：", device.Addresses) //网口地址信息列表包括IP 、 掩码、 广播地址 、P2P
		for _, address := range device.Addresses {
			fmt.Println("- IP 地址为：", address.IP)
			fmt.Println("- 掩码为:", address.Netmask)
			fmt.Println("- 广播地址为：", address.Broadaddr)
			fmt.Println("- P2P地址为：", address.P2P)
			fmt.Println()
		}

	}
}


//获取所有有IP的网络设备名称
func GetAllDevsHaveAddress() (string, error) {
	pcapDevices, err := pcap.FindAllDevs()
	if err != nil {
		return "", errors.New(fmt.Sprintf("list pcapDevices failed: %s", err.Error()))
	}
	var buf strings.Builder
	for _, dev := range pcapDevices {
		fmt.Sprint("Dev:", dev.Name, "\tDes:", dev.Description)
		buf.WriteString(dev.Name)
		if len(dev.Addresses) > 0 {
			for _, ips := range dev.Addresses {
				fmt.Sprint("\tAddr:", ips.IP.String())
				//buf.WriteString(ips.IP.String())
			}

		}
		buf.WriteString("\n")
	}
	return buf.String(), nil
}

//通过IP获取设备名称
func GetDevByIp(ip net.IP) (devName string, err error) {
	devices, err := pcap.FindAllDevs()
	if err != nil {
		return
	}
	for _, d := range devices {
		for _, address := range d.Addresses {
			_ip := address.IP.To4()
			if _ip != nil && _ip.IsGlobalUnicast() && _ip.Equal(ip) {
				return d.Name, nil
			}
		}
	}
	return "", errors.New("can not find dev")
}

2、获取活动网卡IP、网卡MAC、网关、网关mac、活动网卡设备名称

这里主要演示，根据目标IP获取活动网卡的IP、网卡mac、网关、网关mac，然后通过IP获取设备名称

package example

import (
	"errors"
	"fmt"
	"net"

	"github.com/google/gopacket/pcap"
	"github.com/google/gopacket/routing"
	"github.com/jackpal/gateway"
	"github.com/libp2p/go-netroute"
)

// 查找与指定IP地址相匹配的本地IP地址和MAC地址,其实就是检测是否同网段
func GetIfaceMac(ifaceAddr net.IP) (src net.IP, mac net.HardwareAddr) {
	interfaces, _ := net.Interfaces()  //获取本地计算机上的网络接口信息
	for _, iface := range interfaces { //遍历所有网络接口
		if addrs, err := iface.Addrs(); err == nil { //获取接口的IP地址列表
			for _, addr := range addrs { //遍历该接口的IP地址
				if addr.(*net.IPNet).Contains(ifaceAddr) { //检查每个IP地址是否包含了给定的ifaceAddr（即传参），这里用的contains方法，检查给定IP和接口IP是否同一子网
					return addr.(*net.IPNet).IP, iface.HardwareAddr //匹配就返回接口IP和mac地址
				}
			}

		}

	}
	return nil, nil

}

// 通过IP获取网络设备名称
func GetDevByIp(ip net.IP) (devName string, err error) {
	devices, err := pcap.FindAllDevs() //获取所有网络设备
	if err != nil {
		return
	}

	for _, d := range devices {
		for _, address := range d.Addresses {
			_ip := address.IP.To4()                                   //检测IP是否位ipv4地址
			if _ip != nil && _ip.IsGlobalUnicast() && _ip.Equal(ip) { //满足地址为ipv4，地址等于传入IP、地址是全局单播地址 三个条件则符合
				return d.Name, nil
			}
		}
	}
	return "", errors.New("未能找到对应设备")

}

// 通过扫描的目标IP获取发包的网卡信息，返回源IP、源mac、网关IP、设备名称
func GetIpFromRouter(dstIp net.IP) (srcIp net.IP, srcMac net.HardwareAddr, gw net.IP, devName string, err error) {
	//先验证扫描IP是否同网段
	srcIp, srcMac = GetIfaceMac(dstIp)
	if srcIp == nil {
		//如果不是同网段，则查询路由
		var r routing.Router//创建一个 routing.Router 类型的变量，用于查询路由信息
		r, err = netroute.New() //初始化routing.Router
		if err == nil {
			var iface *net.Interface //创建变量iface用于保存与路由相关的网络接口信息
			iface, gw, srcIp, err = r.Route(dstIp) //通过路由查询路由信息，包括目标IP地址 dstIp 对应的路由信息。iface 保存了与该路由信息关联的网络接口，gw 保存了网关IP地址，srcIp 保存了与该路由信息关联的本地IP地址
			if err == nil {
				if iface != nil {
					srcMac = iface.HardwareAddr //如果找到了与目标IP地址匹配的路由信息，即 iface 不为 nil，则设置 srcMac 为该网络接口的MAC地址。否则，继续下一步
				} else {
					_, srcMac = GetIfaceMac(srcIp)
				}
			}
		}
		//如果在之前的步骤中出现错误或者 srcMac 为 nil，它尝试取得第一个默认网关的信息。
		if err != nil || srcMac == nil {
			//取第一个默认路由
			gw, err = gateway.DiscoverGateway()//获取第一个默认网关的IP地址
			if err == nil {
				srcIp, srcMac = GetIfaceMac(gw)
			}
		}
	}
	gw = gw.To4()
	srcIp = srcIp.To4()
	devName, err = GetDevByIp(srcIp)
	if srcIp == nil || err != nil || srcMac == nil {
		if err == nil {
			err = fmt.Errorf("err")

		}
		return nil, nil, nil, "", fmt.Errorf("no router,%s", err)
	}
	return

}

ps：笔者之前的思路想岔了，执迷于先获取到活动网卡的IP然后通过IP再去获取网卡设备名称，后来反省过来，针对扫描来说是通过目标IP来获取源IP，源mac，网卡信息

3、抓取网卡数据包

var (
	device       string = "\\Device\\NPF_{111223-123344}" //网卡名称，也可使用FindAllDevs函数获得网卡名称，比如\NPF_{6A5F41。。。}
	snapshot_len int32  = 1024                                                   //每个数据包读取的最大长度
	promiscuous  bool   = false                                                  //是否将网口设置为混杂模式，即是否接收目的不为本机的包
	err          error
	timeout      time.Duration = 30 * time.Second //设置抓包返回的超时时间，如果设置成30s，即每30s刷新下数据包，设置为负数，就立即刷新数据包
	handle       *pcap.Handle                     //是一个*Handle类型的返回值，可能作为gopacket其他函数调用时作为函数参数来传递 (一定记得释放掉)
)

func GetPacp() {
	handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout) //打开网络设备并进行实时捕获数据包
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close() //最后一定要关闭handle

	packetSource := gopacket.NewPacketSource(handle, handle.LinkType()) //第一个参数为OpenLive的返回值，指向Handle类型的指针变量handle。第二个参数为handle.LinkType()此参数默认是以太网链路，一般我们抓包，也是从2层以太网链路上抓取。

	//读取数据包，packetSource.Packets()是个channel类型，此处是从channel类型的数据通道中持续的读取网络数据包
	for packet := range packetSource.Packets() {
		fmt.Println(packet)
	}

}

4、解码数据包各layer内容


import (
	"fmt"
	"log"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/google/gopacket/pcap"
)

func DecodeLayers() {
	//打开device
	handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close()
	packetSource2 := gopacket.NewPacketSource(handle, handle.LinkType())
	for packet := range packetSource2.Packets() {
		printPacketInfo(packet)
	}
}

func printPacketInfo(packet gopacket.Packet) {
	// 判断数据包是否为以太网数据包，可解析出源mac地址、目的mac地址、以太网类型（如ip类型）等
	ethernetLayer := packet.Layer(layers.LayerTypeEthernet)
	if ethernetLayer != nil {
		fmt.Println("检测到以太网数据包")
		ethernetPacket, _ := ethernetLayer.(*layers.Ethernet)
		fmt.Println("源 Mac 地址为：", ethernetPacket.SrcMAC)
		fmt.Println("目的 Mac地址为：", ethernetPacket.DstMAC)
		//以太网类型通常是 IPv4，但也可以是 ARP 或其他
		fmt.Println("以太网类型为：", ethernetPacket.EthernetType)
		fmt.Println(ethernetPacket.Payload)
		fmt.Println()
	}

	// 判断数据包是否为IP数据包，可解析出源ip、目的ip、协议号等
	ipLayer := packet.Layer(layers.LayerTypeIPv4) //这里抓取ipv4的数据包
	if ipLayer != nil {
		fmt.Println("检测到IP层数据包")
		ip, _ := ipLayer.(*layers.IPv4)
		// IP layer variables:
		// Version (Either 4 or 6)
		// IHL (IP Header Length in 32-bit words)
		// TOS, Length, Id, Flags, FragOffset, TTL, Protocol (TCP?),
		//Checksum,SrcIP, DstIP
		fmt.Printf("源ip为 %d 目的ip为 %d\n", ip.SrcIP, ip.DstIP)
		fmt.Println("协议版本为：", ip.Version)
		fmt.Println("首部长度为:", ip.IHL)
		fmt.Println("区分服务为：", ip.TOS)
		fmt.Println("总长度为:", ip.Length)
		fmt.Println("标识id为：", ip.Id)
		fmt.Println("标志为：", ip.Flags)
		fmt.Println("片偏移", ip.FragOffset)
		fmt.Println("TTL", ip.TTL)
		fmt.Println("协议Protocol为：", ip.Protocol)
		fmt.Println("校验和为：", ip.Checksum)
		fmt.Println("基础层", ip.BaseLayer)
		fmt.Println("内容contents：", ip.Contents)
		fmt.Println("可选字段为：", ip.Options)
		fmt.Println("填充为：", ip.Padding)
		fmt.Println()
	}

	// 判断数据包是否为TCP数据包，可解析源端口、目的端口、seq序列号、tcp标志位等
	tcpLayer := packet.Layer(layers.LayerTypeTCP)
	if tcpLayer != nil {
		fmt.Println("检测到tcp数据包")
		tcp, _ := tcpLayer.(*layers.TCP)
		// SrcPort, DstPort, Seq, Ack, DataOffset, Window, Checksum, Urgent
		// Bool flags: FIN, SYN, RST, PSH, ACK, URG, ECE, CWR, NS
		fmt.Printf("源端口为 %d 目的端口为 %d\n", tcp.SrcPort, tcp.DstPort)
		fmt.Println("序列号为：", tcp.Seq)
		fmt.Println("确认号为：", tcp.Ack)
		fmt.Println("数据偏移量：", tcp.DataOffset)
		fmt.Println("标志位：", tcp.CWR, tcp.ECE, tcp.URG, tcp.ACK, tcp.PSH, tcp.RST, tcp.SYN, tcp.FIN)
		fmt.Println("窗口大小：", tcp.Window)
		fmt.Println("校验值：", tcp.Checksum)
		fmt.Println("紧急指针：", tcp.Urgent)
		fmt.Println("tcp选项：", tcp.Options)
		fmt.Println("填充：", tcp.Padding)
		fmt.Println()
	}

	//检测数据包中所有的层数
	fmt.Println("所有 数据包 layer有：")
	for _, layer := range packet.Layers() {
		fmt.Println("--", layer.LayerType())
	}

	//检测判断layer是否存在错误
	if err := packet.ErrorLayer(); err != nil {
		fmt.Println("解码数据包的某些部分出错：", err)
	}

}

dayouziei

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
go中网络流量分析gopacket库的使用

gopacket 是 Go 语言的网络数据包处理库，它提供了方便的 API 来读取、分析、修改和生成网络数据包。你可以使用这个库来修改数据包内容，以实现特定的网络测试或安全目的。修改数据包的过程大致如下：使用 gopacket 读取数据包并解码为特定协议的数据结构（如 IP、TCP 等）。修改相应的字段，如源 IP 地址、目的 IP 地址、源端口、目的端口等。将数据包编码为原始字节流并写回网络。通过 gopacket 库可以很方便地实现数据包的修改。
复制链接

扫一扫

专栏目录