2023-06-30 00:22:04 AnQuanKeINFO 来源：ZONE.CI 全球网 0 阅读模式

gopacket 是谷歌开源的项目，它为 Golang 提供捕获及处理网络数据包的能力。其底层基于 libpcap（在 Linux 上）和 npcap（在 Windows 上）。

概述

包 gopacket 为 Go 语言提供数据包解码功能。

gopacket 包含多个带有额外功能的子包，包括：

layers：每次都可能使用该子包。它包含内置于 gopacket 的用于解码数据包协议的逻辑。注意，下面的所有示例代码假定已经导入 gopacket 和 gopacket/layers。
pcap：使用 libpcap 从网络读取数据包的 C 绑定。
pfring：使用 PF_RING 从网络读取数据包的 C 绑定。
afpacket：从网络上读取数据包的 Linux AF_PACKET 的 C 绑定。
tcpassembly：TCP 流重组。

此外，如果打算直接编写代码，那么请查看 examples （https://github.com/Google/gopacket/tree/master/examples）子目录，其中包含许多使用 gopacket 库构建的简单二进制示例。

由于 x/sys/unix 依赖，pcapgo/EthernetHandle、afpacket 和 bsdbpf 至少需要 Go 1.7。除此之外，所需的最小 Go 版本是 1.5。

基本应用

gopacket 以 []byte 的形式接收数据包数据，并且将其解码为具有非零“层”数的数据包。每层对应于字节中的一个协议。解码数据包后，可以从数据包中请求数据包的层。

// Decode a packet packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Default) // Get the TCP layer from this packet if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil { fmt.Println(“This is a TCP packet!”) // Get actual TCP data from this layer tcp, _ := tcpLayer.(*layers.TCP) fmt.Printf(“From src port %d to dst port %d\n”, tcp.SrcPort, tcp.DstPort) } // Iterate over all layers, printing out each layer type for _, layer := range packet.Layers() { fmt.Println(“PACKET LAYER:”, layer.LayerType()) }

可以从许多起始点解码数据包。许多基础类型都实现了 Decoder 接口，这使我们能够解码我们没有完整数据的数据包。

// Decode an ethernet packet ethP := gopacket.NewPacket(p1, layers.LayerTypeEthernet, gopacket.Default) // Decode an IPv6 header and everything it contains ipP := gopacket.NewPacket(p2, layers.LayerTypeIPv6, gopacket.Default) // Decode a TCP header and its payload tcpP := gopacket.NewPacket(p3, layers.LayerTypeTCP, gopacket.Default)

从源读取数据包

大多数情况下，你不会只是拥有数据包数据的 []byte。相反，你将希望从某处（文件、接口等）读取数据包，然后处理它们。为此，需要构建 PacketSource。

首先，需要构造实现 PacketDataSource 接口的对象。在 gopacket/pcap 和 gopacket/pfring 子包中，有该接口的实现…请查看文档，了解关于其用法的更多信息。一旦拥有 PacketDataSource，可以将其与选择的解码器一起传进 NewPacketSource，创建 PacketSource。

一旦拥有 PacketSource，可以以多种方式从其中读取数据包。请查看 PacketSource 的文档，了解更多细节。最简单的方式是 Packets 函数，该函数返回一个 Channel，然后异步地将数据包写进该 Channel，如果 packetSource 达到文件结束（end-of-file），则关闭 Channel。

packetSource := … // construct using pcap or pfring for packet := range packetSource.Packets() { handlePacket(packet) // do something with each packet }

可以通过设置 packetSource.DecodeOptions 中的字段更改 packetSource 的解码选项…查看下面的部分，了解更多细节。

惰性解码

gopacket 选择性地惰性解码数据包数据，这意味着它只在需要处理函数调用时解码数据包层。

// Create a packet, but don’t actually decode anything yet packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy) // Now, decode the packet up to the first IPv4 layer found but no further. // If no IPv4 layer was found, the whole packet will be decoded looking for // it. 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()

惰性解码的数据包不是并发安全的（concurrency-safe）。由于并非所有层都已解码，所以每次调用 Layer() 或 Layers() 都可能修改数据包，以解码下一层。如果在多个协程中并发地使用数据包，那么不要使用 gopacket.Lazy 选项。此时，gopacket 将完全解码数据包，所有未来的函数调用将不修改该对象。

无拷贝解码

默认情况下，gopacket 将拷贝传递给 NewPacket 的切片，在数据包内存储该拷贝。因此对切片下层的字节的修改不会影响数据包及其层。如果可以保证不更改底层切片字节，那么使用 NoCopy 告诉 gopacket.NewPacket，它将使用被传入的切片本身。

// This channel returns new byte slices, each of which points to a new // memory location that’s guaranteed immutable for the duration of the // packet. for data := range myByteSliceChannel { p := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy) doSomethingWithPacket(p) }

最快的解码方式是同时使用 Lazy 和 NoCopy，但是请注意，从上面的许多警告中可以看出，对于某些实现来说，其中之一或两者都可能是危险的。

已知层的指针

在解码过程中，某些层作为已知的层类型被存储在数据包中。比如 IPv4 和 IPv6 都是 NetworkLayer 层，而 TCP 和 UDP 都是 TransportLayer 层。gopacket 支持 4 个层，对应于 TCP/IP 分层模式的 4 个层（大致相当于 OSI 模型的 2、3、4 和 7 层）。可以使用 packet.LinkLayer、packet.NetworkLayer、packet.TransportLayer 和 packet.ApplicationLayer 函数，访问这些层。这些函数返回相应的接口（gopacket.{Link,Network,Transport,Application}Layer），前三层提供用于获取该特定层的源地址/目标地址的方法，而最后一层提供用于获取负载数据的 Payload 方法。这很有用，比如，获取所有数据包的负载，而不管其底层数据类型如何：

// Get packets from some source for packet := range someSource { if app := packet.ApplicationLayer(); app != nil { if strings.Contains(string(app.Payload()), “magic string”) { fmt.Println(“Found magic string in a packet!”) } } }

ErrorLayer 是特别有用的层，它在数据包的解析部分存在错误时被设置。

packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Default) if err := packet.ErrorLayer(); err != nil { fmt.Println(“Error decoding some part of the packet:”, err) }

请注意，我们没有从 NewPacket 返回错误，因为我们在遇到错误层之前，可能已经成功解码了许多层。即便 TCP 层格式不正确，仍然可以正确地获取 Ethernet 和 IPv4 层。

Flow 和 Endpoint

gopacket 有两个有用的对象，Flow 和 Endpoint，用于以协议无关的方式，传达数据包来自于 A，进入 B 的事实。常用的层类型 LinkLayer、NetworkLayer 和 TransportLayer 都提供用于提取其 Flow 信息的方法，而无需关心底层 Layer 的类型。

Flow 是简单的对象，由两个 Endpoint 组成，一个源和一个目的地。它详细地说明数据包的某一层的发送方和接收方。

Endpoint 是源或目的地的可哈希表示。比如，对于 LayerTypeIPv4，Endpoint 包含 v4 IP 数据包的 IP 地址字节。Flow 可以分解为 Endpoint，Endpoint 可以组合成 Flow：

packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy) netFlow := packet.NetworkLayer().NetworkFlow() src, dst := netFlow.Endpoints() reverseFlow := gopacket.NewFlow(dst, src)

Endpoint 和 Flow 都能用作映射键，相等运算符可以比较它们，因此根据端点准则，可以很容易地将所有数据包分组在一起：

flows := map[gopacket.Endpoint]chan gopacket.Packet packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy) // Send all TCP packets to channels based on their destination port. if tcp := packet.Layer(layers.LayerTypeTCP); tcp != nil { flows[tcp.TransportFlow().Dst()] <- packet } // Look for all packets with the same source and destination network address if net := packet.NetworkLayer(); net != nil { src, dst := net.NetworkFlow().Endpoints() if src == dst { fmt.Println(“Fishy packet has same network source and dst: %s”, src) } } // Find all packets coming from UDP port 1000 to UDP port 500 interestingFlow := gopacket.FlowFromEndpoints(layers.NewUDPPortEndpoint(1000), layers.NewUDPPortEndpoint(500)) if t := packet.NetworkLayer(); t != nil && t.TransportFlow() == interestingFlow { fmt.Println(“Found that UDP flow I was looking for!”) }

出于负载均衡的目的，Flow 和 Endpoint 都拥有 FastHash() 函数，该函数提供其内容的快速、非加密散列。特别重要的是 Flow FastHash() 是对称的：A -> B 与 B -> A 具有相同的哈希值。示例用法如下：

channels := [8]chan gopacket.Packet for i := 0; i < 8; i++ { channels[i] = make(chan gopacket.Packet) go packetHandler(channels[i]) } for packet := range getPackets() { if net := packet.NetworkLayer(); net != nil { channels[int(net.NetworkFlow().FastHash()) & 0x7] <- packet } }

这允许我们拆分数据包流，同时仍然确保每个流看到一个 Flow（及其双向的反向）的所有数据包。

实现自己的解码器

如果你的网络有一些奇怪的封装，那么可以实现自己的解码器。在本例中，我么处理用 4 字节头封装的 Ethernet 数据包。

// Create a layer type, should be unique and high, so it doesn’t conflict, // giving it a name and a decoder to use. var MyLayerType = gopacket.RegisterLayerType(12345, gopacket.LayerTypeMetadata{Name: “MyLayerType”, Decoder: gopacket.DecodeFunc(decodeMyLayer)}) // Implement my layer type MyLayer struct { StrangeHeader []byte payload []byte } func (m MyLayer) LayerType() gopacket.LayerType { return MyLayerType } func (m MyLayer) LayerContents() []byte { return m.StrangeHeader } func (m MyLayer) LayerPayload() []byte { return m.payload } // Now implement a decoder… this one strips off the first 4 bytes of the // packet. func decodeMyLayer(data []byte, p gopacket.PacketBuilder) error { // Create my layer p.AddLayer(&MyLayer{data[:4], data[4:]}) // Determine how to handle the rest of the packet return p.NextDecoder(layers.LayerTypeEthernet) } // Finally, decode your packets: p := gopacket.NewPacket(data, MyLayerType, gopacket.Lazy)

有关编码解码器如何工作的更多细节，请查看 Decoder 和 PacketBuilder 的文档，或者查看 RegisterLayerType 和 RegisterEndpointType，以了解如何向 gopacket 添加 Layer/Endpoint 类型。

使用 DecodingLayerParser 快速解码

TLDR（Too Long，Didn’t Read）：DecodingLayerParser 解码数据包数据花费的时间大约是 NewPacket 的 10%，但仅适用于已知的数据包堆栈。

使用 gopacket.NewPacket 或 PacketSource.Packets 的基本解码有些慢，因为它需要分配新数据包和每个相应的层。它非常通用，可以处理所有已知的层类型，但有时只关心特定的一组层，所以这种通用性是浪费的。

DecodingLayerParser 通过直接将数据包层解码进预分配对象的方式，完全地避免内存分配，然后可以引用这些对象，获取数据包的信息。示例如下：

func main() { var eth layers.Ethernet var ip4 layers.IPv4 var ip6 layers.IPv6 var tcp layers.TCP parser := gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, &eth, &ip4, &ip6, &tcp) decoded := []gopacket.LayerType{} for packetData := range somehowGetPacketData() { if err := parser.DecodeLayers(packetData, &decoded); err != nil { fmt.Fprintf(os.Stderr, “Could not decode layers: %v\n”, err) continue } for _, layerType := range decoded { switch layerType { case layers.LayerTypeIPv6: fmt.Println(” IP6 “, ip6.SrcIP, ip6.DstIP) case layers.LayerTypeIPv4: fmt.Println(” IP4 “, ip4.SrcIP, ip4.DstIP) } } } }

这里需要注意的重要事项是，解析器修改传入的层（eth、ip4、ip6、tcp），而非分配新层，因此极大地加快了解码过程。它甚至基于层类型进行分支…它将处理 (eth, ip4, tcp) 或 (eth, ip6, tcp) 堆栈。但它不处理任何其它类型…由于没有传入其它解码器， (eth, ip4, udp) 堆栈将在 ip4 后，停止解码，并且只通过 “decoded” 切片传回 [LayerTypeEthernet, LayerTypeIPv4]（以及说明无法解码 UDP 数据包的错误）。

不幸的是，并非所有层都可以被 DecodingLayerParser 使用…只有实现 DecodingLayer 接口的层才是可用的。此外，可以创建不是 Layer 本身的 DecodingLayer…请查看 layers.IPv6ExtensionSkipper，以获取示例。

使用 DecodingLayerContainer 实现更快的和自定义解码

默认情况下，DecodingLayerParser 使用原生 Map 存储和搜索要解码的层。虽然是通用的，但在某些情况下，该方案可能不是最优的。比如，如果只有几层，那么通过稀疏数组索引或线性数组扫描可能提供更快的操作。

为适应这些场景，引入了 DecodingLayerContainer 接口及其实现：DecodingLayerSparse、DecodingLayerArray 和 DecodingLayerMap。可以使用 SetDecodingLayerContainer 方法指定 DecodingLayerParser 的容器实现。示例：

dlp := gopacket.NewDecodingLayerParser(LayerTypeEthernet) dlp.SetDecodingLayerContainer(gopacket.DecodingLayerSparse(nil)) var eth layers.Ethernet dlp.AddDecodingLayer(&eth) // … add layers and use DecodingLayerParser as usual…

如果想跳过间接层（尽管牺牲一些功能），那么可以使用 DecodingLayerContainer 作为解码工具。在这种情况下，必须自己处理未知的层类型和 Panic。示例：

func main() { var eth layers.Ethernet var ip4 layers.IPv4 var ip6 layers.IPv6 var tcp layers.TCP dlc := gopacket.DecodingLayerContainer(gopacket.DecodingLayerArray(nil)) dlc = dlc.Put(&eth) dlc = dlc.Put(&ip4) dlc = dlc.Put(&ip6) dlc = dlc.Put(&tcp) // you may specify some meaningful DecodeFeedback decoder := dlc.LayersDecoder(LayerTypeEthernet, gopacket.NilDecodeFeedback) decoded := make([]gopacket.LayerType, 0, 20) for packetData := range somehowGetPacketData() { lt, err := decoder(packetData, &decoded) if err != nil { fmt.Fprintf(os.Stderr, “Could not decode layers: %v\n”, err) continue } if lt != gopacket.LayerTypeZero { fmt.Fprintf(os.Stderr, “unknown layer type: %v\n”, lt) continue } for _, layerType := range decoded { // examine decoded layertypes just as already shown above } } }

DecodingLayerSparse 是最快的，但在使用的层可以解码的 LayerType 值不大时最有效，否则可能导致更大的内存占用。DecodingLayerArray 非常紧凑，主要用于解码层数不多的情况（最多约 10-15 层，但请自行进行基准测试）。DecodingLayerMap 是最通用的，默认情况下，DecodingLayerParser 使用 DecodingLayerMap。请参考层子包中的测试和基准测试，以进一步了解使用示例和性能度量。

如果希望使用自己内部的数据包解码逻辑，那么可以选择实现自己的 DecodingLayerContainer。

创建数据包数据

除提供解码数据包数据的能力外，gopacket 还允许从头开始创建数据包。许多 gopacket 层实现了 SerializableLayer 接口；可以通过以下方式，将这些层序列化为 []byte：

ip := &layers.IPv4{ SrcIP: net.IP{1, 2, 3, 4}, DstIP: net.IP{5, 6, 7, 8}, // etc… } buf := gopacket.NewSerializeBuffer() opts := gopacket.SerializeOptions{} // See SerializeOptions for more details. err := ip.SerializeTo(buf, opts) if err != nil { panic(err) } fmt.Println(buf.Bytes()) // prints out a byte slice containing the serialized IPv4 layer.

SerializeTo 将给定的层前置到 SerializeBuffer，将当前缓冲区的 Bytes() 切片视为序列化层的有效负载。因此，可以通过以相反顺序序列化一组层（比如，负载，然后 TCP，然后 IP，然后 Ethernet）的方式，序列化整个数据包。SerializeBuffer 的 SerializeLayers 函数是完成该任务的辅助函数。

比如，为生成一个（空的，并且无用的，因为未设置字段）Ethernet（IPv4(TCP(Payload))）数据包，可以运行：

buf := gopacket.NewSerializeBuffer() opts := gopacket.SerializeOptions{} gopacket.SerializeLayers(buf, opts, &layers.Ethernet{}, &layers.IPv4{}, &layers.TCP{}, gopacket.Payload([]byte{1, 2, 3, 4})) packetData := buf.Bytes()

最后说明

如果使用 gopacket，那么几乎肯定希望确保已导入 gopacket/layers，因为导入时，它将设置所有 LayerType 变量，填充许多令人关注的变量/映射（DecodersByLayerName 等）。因此，建议即便不直接使用任何层函数，仍然使用下面的代码导入它：

import ( _ “github.com/Google/gopacket/layers” )

TCP 流重组

环境说明

操作系统：Ubuntu 20.10
Go：go version go1.20.3 linux/amd64

· 设置代理

$ go env -w GOPROXY=https://goproxy.cn,direct

安装 libpcap

下载 libpcap 源码

本文使用https://www.tcpdump.org/release/libpcap-1.10.4.tar.gz

解压、切换目录

$ tar zxvf libpcap-1.10.4.tar.gz $ cd libpcap-1.10.4/

安装依赖

$ sudo apt install -y gcc flex bison make

编译

$ ./configure $ make $ sudo make install

重建动态库缓存

$ sudo ldconfig # 查看 $ sudo ldconfig -p | grep -i pcap

TCP 流重组示例

创建项目

$ mkdir gopacket-tcp-reassembly-test $ cd gopacket-tcp-reassembly-test/ $ go mod init gopacket-tcp-reassembly-test $ go get -u github.com/Google/[email protected]

在项目目录下，创建 main.go：

package main import ( “bufio” “bytes” “flag” “github.com/Google/gopacket” “github.com/Google/gopacket/layers” “github.com/Google/gopacket/pcap” “github.com/Google/gopacket/tcpassembly” “github.com/Google/gopacket/tcpassembly/tcpreader” “io” “log” “net/http” “sync” “time” ) // Cache 用于检索响应对应的请求。这样做的原因包括： // 1. 解析 HTTP 响应时，需要相应的请求对象 // 2. 将响应和请求配对 type Cache struct { mtx sync.RWMutex // 格式为：{网络层哈希值: {传输层哈希值: 请求对象, …}, …} m map[uint64]map[uint64]*http.Request // 用于判断 Flow 是请求还是响应 requests map[string]struct{} } func NewCache() *Cache { return &Cache{ m: make(map[uint64]map[uint64]*http.Request), requests: make(map[string]struct{}), } } // Get 用于在解析响应前，从 Cache 中获取请求 func (c *Cache) Get(netHash, transportHash uint64) *http.Request { c.mtx.RLock() defer c.mtx.RUnlock() if transportMap, found := c.m[netHash]; found { if r, found := transportMap[transportHash]; found { return r } } return nil } // Set 用于在解析完请求后，将其保存到 Cache 中 func (c *Cache) Set(net, transport gopacket.Flow, r *http.Request) { c.mtx.Lock() defer c.mtx.Unlock() transportMap, found := c.m[net.FastHash()] if found { transportMap[transport.FastHash()] = r } else { c.m[net.FastHash()] = map[uint64]*http.Request{transport.FastHash(): r} } c.requests[net.Src().String()+”:”+transport.Src().String()] = struct{}{} } // Delete 用于从 Cache 中删除条目 func (c *Cache) Delete(net, transport gopacket.Flow) { c.mtx.Lock() defer c.mtx.Unlock() // 如果是请求，那么删除 requests 中的条目 key := net.Src().String() + “:” + transport.Src().String() if _, found := c.requests[key]; found { delete(c.requests, key) return } // 如果是响应，那么删除缓存的请求对象 transportMap, found := c.m[net.FastHash()] if !found { return } delete(transportMap, transport.FastHash()) if len(transportMap) == 0 { delete(c.m, net.FastHash()) } } var cache = NewCache() // httpStream 真正地处理 HTTP 请求的解码 type httpStream struct { net, transport gopacket.Flow r tcpreader.ReaderStream } func (h *httpStream) run() { buf := bufio.NewReader(&h.r) for { var err error // Magic Number 用于确定协议。比如 HTTP 请求报文、HTTP 响应报文 var magicNumber []byte var resp *http.Response var req *http.Request isResponse := false // PEEK（返回下 N 个字节，但不推进 Reader）出前 2 个字节，以确定 Magic Number magicNumber, err = buf.Peek(2) if err != nil { // 如果遇到其它错误，那么先打印错误信息，再返回 if err != io.EOF { log.Printf(“Error peeking magic number, %s\n”, err) } else { // 如果遇到 EOF，那么清理缓存 cache.Delete(h.net, h.transport) } return } // 如果前 2 个字节是 HT，那么认为该 Flow 是 HTTP 响应 if bytes.Equal(magicNumber, []byte{‘H’, ‘T’}) { isResponse = true } if isResponse { resp, err = http.ReadResponse(buf, cache.Get(h.net.FastHash(), h.transport.FastHash())) } else { if req, err = http.ReadRequest(buf); err == nil { cache.Set(h.net, h.transport, req) } } if err == io.EOF { // 必须读到 EOF…非常重要！ cache.Delete(h.net, h.transport) return } else if err != nil { log.Printf(“Error reading stream, %s, %s, %s”, h.net, h.transport, err) continue } if req != nil { body, _ := io.ReadAll(req.Body) _ = req.Body.Close() log.Printf(“http request: %#v\n”, *req) log.Println(string(body)) } else { body, _ := io.ReadAll(resp.Body) // 读完 resp.Body 时，必须调用 resp.Body.Close _ = resp.Body.Close() log.Printf(“http response: %#v\n”, *resp) log.Println(string(body)) } } } // 使用 tcpassembly.StreamFactory 和 tcpassembly.Stream 接口，构建 HTTP 请求解析器。 // httpStreamFactory 实现 tcpassembly.StreamFactory type httpStreamFactory struct{} func (h *httpStreamFactory) New(net, transport gopacket.Flow) tcpassembly.Stream { hs := &httpStream{ net: net, transport: transport, r: tcpreader.NewReaderStream(), } // 重要…必须保证读取 reader 流的数据 go hs.run() // ReaderStream 实现 tcpassembly.Stream, 因此可以返回指向它的指针 return &hs.r } func main() { // 解析命令行参数 var iface = flag.String(“i”, “eth0”, “Interface to get packets from”) var snaplen = flag.Int(“s”, 1600, “SnapLen for pcap packet capture”) flag.Parse() var handle *pcap.Handle var err error // pcap.OpenLive 打开设备，返回 *pcap.Handle。 // 它接受设备名称（eth0），每个数据包的最大大小（snaplen），是否将接口设置为混杂模式（即是否接收目的地址不为本机的包），以及超时作为参数。 // 警告：该函数仅接受毫秒时间戳。对于纳秒解决方案，使用 pcap.InactiveHandle。 // 如果将 timeout 设置为 30s，那么每 30s 刷新一次数据包；设置成负数，将立刻刷新数据包 handle, err = pcap.OpenLive(*iface, int32(*snaplen), true, time.Second) if err != nil { log.Panic(err) } // 务必释放 Handle defer handle.Close() // 设置 TCP 流重组 // 1. 创建 httpStreamFactory 结构体，实现 tcpassembly.StreamFactory 接口 streamFactory := &httpStreamFactory{} // 2. 创建连接池 streamPool := tcpassembly.NewStreamPool(streamFactory) // 3. 创建重组器 assembler := tcpassembly.NewAssembler(streamPool) // 创建数据包源。 // handle.LinkType() 表示从 2 层以太网链路上抓取数据包 packetSource := gopacket.NewPacketSource(handle, handle.LinkType()) // 从该 Channel 中，持续地读取数据包 packets := packetSource.Packets() ticker := time.Tick(time.Minute) for { select { case packet := <-packets: if packet.NetworkLayer() == nil || packet.TransportLayer() == nil || packet.TransportLayer().LayerType() != layers.LayerTypeTCP { log.Println(“Unusable packet”) continue } tcp := packet.TransportLayer().(*layers.TCP) // 4. 将数据包添加到重组器中 assembler.AssembleWithTimestamp(packet.NetworkLayer().NetworkFlow(), tcp, packet.Metadata().Timestamp) case <-ticker: // 每隔 1 分钟，刷新之前 2 分钟内不活跃的连接 assembler.FlushOlderThan(time.Now().Add(time.Minute * -2)) } } }

安装测试 Nginx

$ sudo apt install -y nginx # 测试 Nginx 是否成功启动 $ curl http://127.0.0.1

启动数据包捕获程序

# 在项目目录下执行 $ sudo go run main.go -i lo

访问 Nginx

$ curl http://127.0.0.1

数据包捕获程序将输出重组的 HTTP 请求和响应。

其它示例

迭代当前机器上的所有网络接口

package main import ( “fmt” “github.com/Google/gopacket/pcap” “log” ) func main() { // 尝试迭代当前机器上的所有接口 devices, err := pcap.FindAllDevs() if err != nil { log.Panic(err) } // 打印设备信息 fmt.Println(“Devices found:”) for _, device := range devices { fmt.Println(“\nName: “, device.Name) fmt.Println(“Description: “, device.Description) fmt.Println(“Devices addresses:”) for _, address := range device.Addresses { fmt.Println(“- IP address: “, address.IP) fmt.Println(“- Subnet mask: “, address.Netmask) } } }