go中网络流量分析gopacket库的使用
一、前言
近来，笔者想学习下用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)
}
}