gopacket
文档地址:https://godoc.org/github.com/google/gopacket
视频介绍:https://www.youtube.com/watch?v=APDnbmTKjgM
子包
- layers: 用于解码数据包协议
- pcap: 使用libpcap来读取数据包
- pfring: 使用PF_RING来读取数据包
- afpacket: 使用Linux’s AF_PACKET来读取数据包
- tcpassembly: TCP流重组
- gopacket使用示例:https://colobu.com/2019/06/01/packet-capture-injection-and-analysis-gopacket/
- 流重组示例:https://github.com/google/gopacket/blob/master/examples/httpassembly/main.go
pcap处理
查看版本
version := pcap.Version()
fmt.Println(version)
测试(Win10 x64):Npcap version 1.00, based on libpcap version 1.9.1
网络接口
类型:pcap.Interface
type Interface struct {
Name string
Description string
Flags uint32
Addresses []InterfaceAddress
}
type InterfaceAddress struct {
IP net.IP
Netmask net.IPMask // Netmask may be nil if we were unable to retrieve it.
Broadaddr net.IP // Broadcast address for this IP may be nil
P2P net.IP // P2P destination address for this IP may be nil
}
查找网络设备:
var devices []pcap.Interface
devices, _ = pcap.FindAllDevs()
fmt.Println(devices)
实时捕获
handle, err := pcap.OpenLive("\\Device\\NPF_{5C9384EF-DEBA-43A6-AE6A-5D10C952C481}", int32(65535), true, -1 * time.Second)
if err != nil {
log.Fatal(err)
}
defer handle.Close()
pcap.OpenLive
参数:
- 设备名:
pcap.FindAllDevs()
返回的设备的Name - snaplen:捕获一个数据包的多少个字节,一般来说对任何情况65535是一个好的实践,如果不关注全部内容,只关注数据包头,可以设置成1024
- promisc:设置网卡是否工作在混杂模式,即是否接收目的地址不为本机的包
- timeout:设置抓到包返回的超时。如果设置成30s,那么每30s才会刷新一次数据包;设置成负数,会立刻刷新数据包,即不做等待
- 要记得释放掉handle
打开pcap
handle, _ = pcap.OpenOffline("dump.pcap")
defer handle.Close()
创建一个数据包源
通过监听设备的实时流量或者来自文件的数据包,得到了一个handle,通过这个handle得到一个数据包源packetSource。
packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
利用handle.LinkType()
就不用知道链路类型了。
读取数据包
读取一个数据包:packet, _ := packetSource.NextPacket()
获得一个可以读取数据包的channel来读取全部数据包
packet := packetSource.Packets()
for packet := range packet{
fmt.Println(packet)
}
设置过滤器
使用BPF语法即可。
handle.SetBPFFilter("tcp and port 80")
创建一个pcap用于写入
dumpFile, _ := os.Create("dump.pcap")
defer dumpFile.Close()
packetWriter := pcapgo.NewWriter(dumpFile)
packetWriter.WriteFileHeader(65535, layers.LinkTypeEthernet)
packetWriter.WriteFileHeader
的参数是snaplen和链路类型
写入数据包
packet := packetSource.Packets()
for packet := range packet{
packetWriter.WritePacket(packet.Metadata().CaptureInfo, packet.Data())
}
packet处理
列出所有层
for _, layer := range packet.Layers() {
fmt.Println(layer.LayerType())
fmt.Println(layer.LayerContents())
fmt.Println(layer.LayerPayload())
}
-
layer.LayerType()
:这层的类型 -
layer.LayerContents()
:当前层的内容 -
layer.LayerPayload()
:当前层承载的payload(不包括当前层)
分析某层的数据
IPv4
ipLayer := packet.Layer(layers.LayerTypeIPv4)
if ipLayer != nil {
ip, _ := ipLayer.(*layers.IPv4)
fmt.Println(ip.SrcIP, ip.DstIP)
fmt.Println(ip.Protocol)
}
TCP
tcpLayer := packet.Layer(layers.LayerTypeTCP)
if tcpLayer != nil {
ip, _ := tcpLayer.(*layers.TCP)
fmt.Println(ip.SrcPort, ip.DstPort)
}
这里有一些需要注意的:
-
tcpLayer
是通过接口packet.Layer
返回的一个Layer
,一个指向layers.TCP
的指针 -
tcp
是layers.TCP
这个具体类型的指针,也可以说tcp
是真实的tcp层数据
单独的解码器
可以从多个起点对数据包进行解码。可以解码没有完整数据的数据包。
// Decode an ethernet packet
ethP := gopacket.NewPacket(packet, layers.LayerTypeEthernet, gopacket.Default)
// Decode an IPv6 header and everything it contains
ipP := gopacket.NewPacket(packet, layers.LayerTypeIPv6, gopacket.Default)
// Decode a TCP header and its payload
tcpP := gopacket.NewPacket(packet, layers.LayerTypeTCP, gopacket.Default)
懒惰解码(Lazy Decoding)
创建一个packet包,但是不立刻解码,只有后面需要用的时候再解码。比如第二行解码IPv4层,如果有的话,就解码IPv4层,然后不做进一步处理(不解码后续的层);如果没有会解码整个packet来寻找IPv4层。packet.Layers()
会解码所有层并且返回,已经解码的层不会再次做解码。
注意:这种方式并不是并发安全的,对Layers的每次调用可能会改变数据包。
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
ip4 := packet.Layer(layers.LayerTypeIPv4)
// Decode all layers and return them. The layers up to the first IPv4 layer
// are already decoded, and will not require decoding a second time.
layers := packet.Layers()
NoCopy解码
上述两种解码方式会复制切片,对切片的字节进行更改不会影响数据包本身。如果可以保证不修改切片,可以使用NoCopy。
for data := range myByteSliceChannel {
p := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy)
doSomethingWithPacket(p)
}
快速解码
不会创建新的内存结构。会重用内存结构,所以只能用于预定义好层的结构。
for packet := range packetSource.Packets() {
var eth layers.Ethernet
var ip4 layers.IPv4
var tcp layers.TCP
parser := gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, ð, &ip4, &tcp)
var decodedLayers []gopacket.LayerType
parser.DecodeLayers(packet.Data(), &decodedLayers)
for _, layerType := range decodedLayers {
fmt.Println(layerType)
}
}
自定义层数据
注册自定义的层
21:19开始
创建与发送
创建
创建一个新的序列化缓冲区;然后把所有层序列化到缓冲区中。
buffer := gopacket.NewSerializeBuffer()
options := gopacket.SerializeOptions{}
gopacket.SerializeLayers(buffer, options, &layers.Ethernet{}, &layers.IPv4{}, &layers.TCP{}, gopacket.Payload([]byte{65, 66, 67}))
发送数据包
handle.WritePacketData(buffer.Bytes())
流和端点(Flow and Endpoint)
注意:这个地方官方文档感觉有坑
-
pkt.NetworkLayer().NetworkFlow()
:取网络层,网络流,IP地址 -
pkt.TransportLayer().TransportFlow()
:取传输层,传输端点,端口 -
interestingFlow
:定义好端点,对网络数据做匹配
pkt := gopacket.NewPacket(packet.Data(), layers.LayerTypeEthernet, gopacket.Lazy)
netFlow := pkt.NetworkLayer().NetworkFlow()
src, dst := netFlow.Endpoints()
fmt.Println(src, dst)
fmt.Println("Done.")
tcpFlow := pkt.TransportLayer().TransportFlow()
fmt.Println(tcpFlow.Endpoints())
interestingFlow, _ := gopacket.FlowFromEndpoints(layers.NewUDPPortEndpoint(1000), layers.NewUDPPortEndpoint(500))
if t := pkt.TransportLayer(); t != nil && t.TransportFlow() == interestingFlow {
fmt.Println("Found that UDP flow I was looking for!")
}