【golang】网络数据包捕获库 gopacket

详解 github.com/google/gopacket/pcap 包

github.com/google/gopacket/pcap 是 Go 语言中一个强大的网络数据包捕获库，它是 gopacket 项目标一部分，提供了对 libpcap（Linux/Unix）和 WinPcap（Windows）的 Go 语言绑定，用于及时网络数据包捕获和分析。
核心功能

• 及时网络数据包捕获
  
• 过滤网络流量（BPF过滤器）
  
• 读取息争析pcap文件
  
• 统计网络接口信息
  

基本使用

1. 安装

1. go get github.com/google/gopacket
2. go get github.com/google/gopacket/pcap

复制代码

2. 获取网络接口列表

1. devices, err := pcap.FindAllDevs()
2. if err != nil {
3.     log.Fatal(err)
4. }
6. for _, device := range devices {
7.     fmt.Printf("Device: %s\n", device.Name)
8.     fmt.Printf("Description: %s\n", device.Description)
9.     fmt.Printf("Flags: %d\n", device.Flags)
10.     for _, address := range device.Addresses {
11.         fmt.Printf("\tIP: %s\n", address.IP)
12.         fmt.Printf("\tNetmask: %s\n", address.Netmask)
13.     }
14. }

复制代码

3. 打开网络接口进行捕获

1. handle, err := pcap.OpenLive(
2.     "eth0",    // 接口名
3.     65536,     // 最大包长度
4.     true,      // 是否启用混杂模式
5.     pcap.BlockForever, // 超时时间
6. )
7. if err != nil {
8.     log.Fatal(err)
9. }
10. defer handle.Close()

复制代码

4. 设置BPF过滤器

1. err = handle.SetBPFFilter("tcp and port 80")
2. if err != nil {
3.     log.Fatal(err)
4. }

复制代码

5. 读取数据包

1. packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
2. for packet := range packetSource.Packets() {
3.     // 处理每个数据包
4.     fmt.Println(packet)
5. }

复制代码

高级功能

1. 剖析数据包

1. // 解析以太网层
2. ethernetLayer := packet.Layer(layers.LayerTypeEthernet)
3. if ethernetLayer != nil {
4.     ethernetPacket, _ := ethernetLayer.(*layers.Ethernet)
5.     fmt.Println("Source MAC: ", ethernetPacket.SrcMAC)
6.     fmt.Println("Destination MAC: ", ethernetPacket.DstMAC)
7. }
9. // 解析IP层
10. ipLayer := packet.Layer(layers.LayerTypeIPv4)
11. if ipLayer != nil {
12.     ip, _ := ipLayer.(*layers.IPv4)
13.     fmt.Println("Source IP: ", ip.SrcIP)
14.     fmt.Println("Destination IP: ", ip.DstIP)
15. }
17. // 解析TCP层
18. tcpLayer := packet.Layer(layers.LayerTypeTCP)
19. if tcpLayer != nil {
20.     tcp, _ := tcpLayer.(*layers.TCP)
21.     fmt.Println("Source Port: ", tcp.SrcPort)
22.     fmt.Println("Destination Port: ", tcp.DstPort)
23. }

复制代码

2. 写入pcap文件

1. handle, err := pcap.OpenDead(layers.LinkTypeEthernet, 65536)
2. if err != nil {
3.     log.Fatal(err)
4. }
5. defer handle.Close()
7. writer, err := pcap.NewWriter(handle, "output.pcap")
8. if err != nil {
9.     log.Fatal(err)
10. }
11. defer writer.Close()
13. // 创建并写入数据包
14. // ... (创建数据包代码)
15. err = writer.WritePacket(packet.Metadata().CaptureInfo, packet.Data())
16. if err != nil {
17.     log.Fatal(err)
18. }

复制代码

3. 读取pcap文件

1. handle, err := pcap.OpenOffline("input.pcap")
2. if err != nil {
3.     log.Fatal(err)
4. }
5. defer handle.Close()
7. packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
8. for packet := range packetSource.Packets() {
9.     fmt.Println(packet)
10. }

复制代码

性能优化

• 重用缓冲区：淘汰内存分配
  
  1. var buf [4096]byte
  2. for {
  3.     data, ci, err := handle.ReadPacketData()
  4.     if err != nil {
  5.         continue
  6.     }
  7.     copy(buf[:], data)
  8.     // 处理数据
  9. }

  复制代码
• 零拷贝处理：直接操作原始数据
  
  1. packet := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.Default)

  复制代码
• 并发处理：使用多个goroutine处理数据包
  
  1. packets := make(chan gopacket.Packet, 1000)
  2. go func() {
  3.     for packet := range packetSource.Packets() {
  4.         packets <- packet
  5.     }
  6.     close(packets)
  7. }()
  9. for i := 0; i < runtime.NumCPU(); i++ {
  10.     go func() {
  11.         for packet := range packets {
  12.             // 处理数据包
  13.         }
  14.     }()
  15. }

  复制代码

常见题目

• 权限题目：需要root或管理员权限才气捕获网络数据包
  
• 接口不可用：确保接口名称精确且处于运动状态
  
• 过滤器语法错误：BPF过滤器需要精确语法
  
• 内存走漏：确保及时关闭handle和释放资源
  

实际应用示例

简单的HTTP哀求捕获

1. handle, err := pcap.OpenLive("eth0", 1600, true, pcap.BlockForever)if err != nil {    log.Fatal(err)}defer handle.Close()err = handle.SetBPFFilter("tcp and port 80")
2. if err != nil {
3.     log.Fatal(err)
4. }
5. packetSource := gopacket.NewPacketSource(handle, handle.LinkType())for packet := range packetSource.Packets() {    appLayer := packet.ApplicationLayer()    if appLayer != nil {        payload := appLayer.Payload()        if bytes.Contains(payload, []byte("HTTP")) {            fmt.Printf("%s\n", payload)        }    }}

复制代码

pcap 包是 Go 中网络监控和安全工具开发的基础，结合 gopacket 的其他组件可以构建强大的网络分析工具。

---

---

使用 github.com/google/gopacket/pcap 剖析 DNS 哀求和响应

github.com/google/gopacket/pcap 可以捕获息争析 DNS 哀求和响应，但需要结合 gopacket/layers 包中的 DNS 层剖析功能。
1. 基本 DNS 剖析设置

首先需要导入必要的包：

1. import (
2.     "github.com/google/gopacket"
3.     "github.com/google/gopacket/layers" // 包含DNS层定义
4.     "github.com/google/gopacket/pcap"
5. )

复制代码

2. 捕获 DNS 流量的配置

方法一：捕获全部DNS流量（端口53）

1. handle, err := pcap.OpenLive("eth0", 1600, true, pcap.BlockForever)
2. if err != nil {
3.     panic(err)
4. }
5. defer handle.Close()
7. // 设置BPF过滤器捕获DNS流量（UDP和TCP端口53）
8. err = handle.SetBPFFilter("udp port 53 or tcp port 53")
9. if err != nil {
10.     panic(err)
11. }

复制代码

方法二：区分哀求和响应

1. // 捕获发往DNS服务器的请求
2. err = handle.SetBPFFilter("dst port 53")
4. // 或者捕获来自DNS服务器的响应
5. err = handle.SetBPFFilter("src port 53")

复制代码

3. 剖析DNS数据包

1. packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
2. for packet := range packetSource.Packets() {
3.     // 检查是否包含DNS层
4.     dnsLayer := packet.Layer(layers.LayerTypeDNS)
5.     if dnsLayer != nil {
6.         dns, _ := dnsLayer.(*layers.DNS)
7.         analyzeDNS(dns) // 自定义解析函数
8.     }
9. }

复制代码

4. 详细DNS剖析函数

1. func analyzeDNS(dns *layers.DNS) {
2.     // 判断是请求还是响应
3.     if dns.QR {
4.         fmt.Println("[DNS Response]")
5.     } else {
6.         fmt.Println("[DNS Query]")
7.     }
8.   
9.     // 打印基本信息
10.     fmt.Printf("ID: %d, OpCode: %s, RecursionDesired: %t\n",
11.         dns.ID, dns.OpCode, dns.RD)
12.   
13.     // 解析问题部分（查询的问题）
14.     for _, question := range dns.Questions {
15.         fmt.Printf("Query: %s (Type: %s, Class: %s)\n",
16.             string(question.Name),
17.             question.Type,
18.             question.Class)
19.     }
20.   
21.     // 解析回答部分（响应的资源记录）
22.     for _, answer := range dns.Answers {
23.         fmt.Printf("Answer: %s -> %s (Type: %s, TTL: %d)\n",
24.             string(answer.Name),
25.             getAnswerValue(answer), // 自定义函数获取值
26.             answer.Type,
27.             answer.TTL)
28.     }
29.   
30.     // 解析权威名称服务器部分
31.     for _, ns := range dns.Authorities {
32.         fmt.Printf("Authority: %s -> %s\n",
33.             string(ns.Name),
34.             getAnswerValue(ns))
35.     }
36.   
37.     // 解析附加记录部分
38.     for _, extra := range dns.Additionals {
39.         fmt.Printf("Additional: %s -> %s\n",
40.             string(extra.Name),
41.             getAnswerValue(extra))
42.     }
43. }
45. // 辅助函数：根据类型获取DNS记录的值
46. func getAnswerValue(answer layers.DNSResourceRecord) string {
47.     switch answer.Type {
48.     case layers.DNSTypeA:
49.         return answer.IP.String()
50.     case layers.DNSTypeAAAA:
51.         return answer.IP.String()
52.     case layers.DNSTypeCNAME:
53.         return string(answer.CNAME)
54.     case layers.DNSTypeMX:
55.         return fmt.Sprintf("%s (pref %d)", string(answer.MX), answer.Preference)
56.     case layers.DNSTypeNS:
57.         return string(answer.NS)
58.     case layers.DNSTypeTXT:
59.         return string(answer.TXT)
60.     case layers.DNSTypeSOA:
61.         return fmt.Sprintf("MName: %s, RName: %s", string(answer.SOA.MName), string(answer.SOA.RName))
62.     default:
63.         return fmt.Sprintf("[Unhandled Type %d]", answer.Type)
64.     }
65. }

复制代码

5. 处理TCP DNS流量

DNS通常使用UDP，但大响应大概使用TCP：

1. // 在分析函数中添加TCP处理
2. tcpLayer := packet.Layer(layers.LayerTypeTCP)
3. if tcpLayer != nil {
4.     tcp, _ := tcpLayer.(*layers.TCP)
5.     if tcp.SYN {
6.         // TCP握手开始
7.     } else if len(tcp.Payload) > 0 {
8.         // 尝试解析TCP负载中的DNS
9.         dns := &layers.DNS{}
10.         err := dns.DecodeFromBytes(tcp.Payload, gopacket.NilDecodeFeedback)
11.         if err == nil {
12.             analyzeDNS(dns)
13.         }
14.     }
15. }

复制代码

6. 完整示例：DNS监控工具

1. package main
3. import (
4.     "fmt"
5.     "log"
6.     "time"
7.   
8.     "github.com/google/gopacket"
9.     "github.com/google/gopacket/layers"
10.     "github.com/google/gopacket/pcap"
11. )
13. func main() {
14.     // 1. 获取网络设备
15.     devices, err := pcap.FindAllDevs()
16.     if err != nil {
17.         log.Fatal(err)
18.     }
19.   
20.     // 打印可用设备
21.     fmt.Println("Available devices:")
22.     for _, dev := range devices {
23.         fmt.Printf("- %s", dev.Name)
24.         if dev.Description != "" {
25.             fmt.Printf(" (%s)", dev.Description)
26.         }
27.         fmt.Println()
28.     }
29.   
30.     // 2. 打开设备
31.     var deviceName = "eth0" // 根据实际情况修改
32.     var snapshotLen int32 = 1024
33.     var promiscuous = true
34.     var timeout = 30 * time.Second
35.   
36.     handle, err := pcap.OpenLive(deviceName, snapshotLen, promiscuous, timeout)
37.     if err != nil {
38.         log.Fatal(err)
39.     }
40.     defer handle.Close()
41.   
42.     // 3. 设置过滤器
43.     var filter = "udp port 53 or tcp port 53"
44.     err = handle.SetBPFFilter(filter)
45.     if err != nil {
46.         log.Fatal(err)
47.     }
48.   
49.     // 4. 处理数据包
50.     packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
51.     for packet := range packetSource.Packets() {
52.         processPacket(packet)
53.     }
54. }
56. func processPacket(packet gopacket.Packet) {
57.     // 检查DNS层
58.     dnsLayer := packet.Layer(layers.LayerTypeDNS)
59.     if dnsLayer != nil {
60.         dns, _ := dnsLayer.(*layers.DNS)
61.         printDNSInfo(dns)
62.     }
63.   
64.     // 检查TCP DNS
65.     tcpLayer := packet.Layer(layers.LayerTypeTCP)
66.     if tcpLayer != nil {
67.         tcp, _ := tcpLayer.(*layers.TCP)
68.         if len(tcp.Payload) > 0 && (tcp.SrcPort == 53 || tcp.DstPort == 53) {
69.             dns := &layers.DNS{}
70.             err := dns.DecodeFromBytes(tcp.Payload, gopacket.NilDecodeFeedback)
71.             if err == nil {
72.                 printDNSInfo(dns)
73.             }
74.         }
75.     }
76. }
78. func printDNSInfo(dns *layers.DNS) {
79.     // 打印基本信息
80.     direction := "Query"
81.     if dns.QR {
82.         direction = "Response"
83.     }
84.   
85.     fmt.Printf("\n=== %s ===\n", direction)
86.     fmt.Printf("Transaction ID: 0x%x\n", dns.ID)
87.     fmt.Printf("Flags: %s (QR: %t, OpCode: %s, AA: %t, TC: %t, RD: %t, RA: %t, Z: %d, RCode: %s)\n",
88.         dns.Flags, dns.QR, dns.OpCode, dns.AA, dns.TC, dns.RD, dns.RA, dns.Z, dns.ResponseCode)
89.   
90.     // 打印问题部分
91.     if len(dns.Questions) > 0 {
92.         fmt.Println("\nQuestions:")
93.         for _, q := range dns.Questions {
94.             fmt.Printf("- %s (Type: %s, Class: %s)\n",
95.                 string(q.Name), q.Type, q.Class)
96.         }
97.     }
98.   
99.     // 打印回答部分
100.     if len(dns.Answers) > 0 {
101.         fmt.Println("\nAnswers:")
102.         for _, a := range dns.Answers {
103.             fmt.Printf("- %s: %s (Type: %s, TTL: %d)\n",
104.                 string(a.Name), getDNSRecordValue(a), a.Type, a.TTL)
105.         }
106.     }
107.   
108.     // 打印权威部分
109.     if len(dns.Authorities) > 0 {
110.         fmt.Println("\nAuthorities:")
111.         for _, a := range dns.Authorities {
112.             fmt.Printf("- %s: %s (Type: %s, TTL: %d)\n",
113.                 string(a.Name), getDNSRecordValue(a), a.Type, a.TTL)
114.         }
115.     }
116.   
117.     // 打印附加部分
118.     if len(dns.Additionals) > 0 {
119.         fmt.Println("\nAdditionals:")
120.         for _, a := range dns.Additionals {
121.             fmt.Printf("- %s: %s (Type: %s, TTL: %d)\n",
122.                 string(a.Name), getDNSRecordValue(a), a.Type, a.TTL)
123.         }
124.     }
125. }
127. func getDNSRecordValue(r layers.DNSResourceRecord) string {
128.     switch r.Type {
129.     case layers.DNSTypeA:
130.         return r.IP.String()
131.     case layers.DNSTypeAAAA:
132.         return r.IP.String()
133.     case layers.DNSTypeCNAME:
134.         return string(r.CNAME)
135.     case layers.DNSTypeMX:
136.         return fmt.Sprintf("%s (pref %d)", string(r.MX), r.Preference)
137.     case layers.DNSTypeNS:
138.         return string(r.NS)
139.     case layers.DNSTypePTR:
140.         return string(r.PTR)
141.     case layers.DNSTypeSOA:
142.         return fmt.Sprintf("MName: %s, RName: %s", string(r.SOA.MName), string(r.SOA.RName))
143.     case layers.DNSTypeTXT:
144.         return string(r.TXT)
145.     case layers.DNSTypeSRV:
146.         return fmt.Sprintf("Target: %s, Port: %d, Priority: %d, Weight: %d",
147.             string(r.SRV.Name), r.SRV.Port, r.SRV.Priority, r.SRV.Weight)
148.     default:
149.         return fmt.Sprintf("[Type %d Data]", r.Type)
150.     }
151. }

复制代码

注意事项

• 权限要求：需要root或管理员权限才气捕获网络数据包
  
• 性能考虑：高流量环境下大概需要优化处理逻辑
  
• DNS over HTTPS/TLS：这种方法无法剖析DoH/DoT加密的DNS流量
  
• EDNS扩展：假如需要剖析EDNS扩展信息，需要额外处理OPT记录
  

通过这种组合使用 pcap 和 layers 包，你可以构建功能强大的DNS监控和分析工具，可以或许详细剖析DNS协议的各种细节。

---

• 
  

---

从 layers.DNS 中获取域名和对应 IP 的方法

要从 layers.DNS 数据包中提取域名和对应的 IP 地点，你需要检查 DNS 响应中的回答部分 (Answers)。以下是详细方法和示例代码：
基本方法

• 检查 DNS 响应：确保是 DNS 响应 (QR == true)
  
• 遍历回答记录：检查 Answers 切片
  
• 过滤 A 和 AAAA 记录：获取 IPv4 和 IPv6 地点
  
• 剖析记录数据：将二进制数据转换为可读格式
  

示例代码

1. package main
3. import (
4.     "fmt"
5.     "github.com/google/gopacket"
6.     "github.com/google/gopacket/layers"
7.     "github.com/google/gopacket/pcap"
8.     "net"
9. )
11. func main() {
12.     // 打开网络接口
13.     handle, err := pcap.OpenLive("eth0", 1600, true, pcap.BlockForever)
14.     if err != nil {
15.         panic(err)
16.     }
17.     defer handle.Close()
18.   
19.     // 设置过滤器只捕获 DNS 响应
20.     err = handle.SetBPFFilter("udp and port 53")
21.     if err != nil {
22.         panic(err)
23.     }
24.   
25.     // 开始捕获数据包
26.     packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
27.     for packet := range packetSource.Packets() {
28.         // 检查是否包含 DNS 层
29.         dnsLayer := packet.Layer(layers.LayerTypeDNS)
30.         if dnsLayer == nil {
31.             continue
32.         }
33.       
34.         dns, _ := dnsLayer.(*layers.DNS)
35.       
36.         // 只处理响应包
37.         if !dns.QR {
38.             continue
39.         }
40.       
41.         // 遍历所有回答记录
42.         for _, answer := range dns.Answers {
43.             var ip string
44.          
45.             // 根据记录类型处理
46.             switch answer.Type {
47.             case layers.DNSTypeA:
48.                 // IPv4 地址
49.                 if len(answer.Data) == net.IPv4len {
50.                     ip = net.IP(answer.Data).String()
51.                 }
52.             case layers.DNSTypeAAAA:
53.                 // IPv6 地址
54.                 if len(answer.Data) == net.IPv6len {
55.                     ip = net.IP(answer.Data).String()
56.                 }
57.             default:
58.                 continue // 跳过非IP记录
59.             }
60.          
61.             if ip != "" {
62.                 fmt.Printf("域名: %s, IP: %s, TTL: %d\n",
63.                     string(answer.Name), ip, answer.TTL)
64.             }
65.         }
66.     }
67. }

复制代码

更完整的处理函数

下面是一个更完整的函数，可以处理各种情况：

1. func extractDomainsAndIPs(dns *layers.DNS) map[string][]string {
2.     result := make(map[string][]string)
3.   
4.     // 首先收集所有查询的域名
5.     var domains []string
6.     for _, q := range dns.Questions {
7.         domains = append(domains, string(q.Name))
8.     }
9.   
10.     // 处理回答记录
11.     for _, answer := range dns.Answers {
12.         domain := string(answer.Name)
13.         var ip string
14.       
15.         switch answer.Type {
16.         case layers.DNSTypeA:
17.             if len(answer.Data) >= net.IPv4len {
18.                 ip = net.IP(answer.Data).String()
19.             }
20.         case layers.DNSTypeAAAA:
21.             if len(answer.Data) >= net.IPv6len {
22.                 ip = net.IP(answer.Data).String()
23.             }
24.         case layers.DNSTypeCNAME:
25.             // 处理CNAME记录
26.             cname := string(answer.Data)
27.             result[domain] = append(result[domain], "CNAME: "+cname)
28.             continue
29.         default:
30.             continue
31.         }
32.       
33.         if ip != "" {
34.             result[domain] = append(result[domain], ip)
35.         }
36.     }
37.   
38.     return result
39. }

复制代码

处理特别情况

• CNAME 记录：假如遇到 CNAME 记录，你大概需要继续查找对应的 A/AAAA 记录
  
• 多IP情况：一个域名大概对应多个IP地点
  
• 压缩域名：layers.DNS 已经自动处理了DNS名称压缩
  

性能优化发起

• 预分配切片：假如你知道大致数量，可以预分配切片大小
  
• 重用缓冲区：在处理大量数据包时重用缓冲区
  
• 并行处理：使用 goroutine 池处理数据包
  

完整示例（带CNAME处理）

1. func processDNSResponse(dns *layers.DNS) {
2.     if !dns.QR {
3.         return // 不是响应包
4.     }
5.   
6.     // 创建域名到IP的映射
7.     domainToIPs := make(map[string][]string)
8.     cnameMap := make(map[string]string)
9.   
10.     // 首先处理CNAME记录
11.     for _, answer := range dns.Answers {
12.         if answer.Type == layers.DNSTypeCNAME {
13.             domain := string(answer.Name)
14.             cname := string(answer.Data)
15.             cnameMap[domain] = cname
16.         }
17.     }
18.   
19.     // 然后处理A和AAAA记录
20.     for _, answer := range dns.Answers {
21.         var ip string
22.         domain := string(answer.Name)
23.       
24.         switch answer.Type {
25.         case layers.DNSTypeA:
26.             if len(answer.Data) >= net.IPv4len {
27.                 ip = net.IP(answer.Data).String()
28.             }
29.         case layers.DNSTypeAAAA:
30.             if len(answer.Data) >= net.IPv6len {
31.                 ip = net.IP(answer.Data).String()
32.             }
33.         default:
34.             continue
35.         }
36.       
37.         if ip != "" {
38.             // 检查是否有CNAME链
39.             finalDomain := domain
40.             for {
41.                 if cname, exists := cnameMap[finalDomain]; exists {
42.                     finalDomain = cname
43.                 } else {
44.                     break
45.                 }
46.             }
47.             domainToIPs[finalDomain] = append(domainToIPs[finalDomain], ip)
48.         }
49.     }
50.   
51.     // 打印结果
52.     for domain, ips := range domainToIPs {
53.         fmt.Printf("域名: %s\n", domain)
54.         for _, ip := range ips {
55.             fmt.Printf("  IP: %s\n", ip)
56.         }
57.     }
58. }

复制代码

通过这些方法，你可以有用地从 layers.DNS 数据包中提取域名和对应的IP地点，并处理各种DNS记录类型和特别情况。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。