使用Go和tshark解码IP数据包的网络抓包插件

下面我将介绍如何使用Go语言创建一个名为goshark的网络抓包插件，该插件利用tshark(Wireshark的命令行版本)来解码IP数据包并创建分析结构。

设计思路

1. 使用Go的os/exec包调用tshark命令
2. 解析tshark的JSON输出
3. 将解析结果转换为结构化的Go数据
4. 提供分析功能接口

代码实现

package goshark

import (
	"bytes"
	"encoding/json"
	"fmt"
	"os/exec"
	"strings"
)

// Packet 表示解码后的网络数据包
type Packet struct {
	Timestamp   string            `json:"timestamp"`
	Source      string            `json:"source"`
	Destination string            `json:"destination"`
	Protocol    string            `json:"protocol"`
	Length      int               `json:"length"`
	Info        string            `json:"info"`
	Layers      map[string]interface{} `json:"layers"`
}

// Goshark 主结构体
type Goshark struct {
	Interface string   // 网络接口
	Filter    string   // BPF过滤器
	Count     int      // 抓包数量
	Fields    []string // 要提取的字段
}

// New 创建一个新的Goshark实例
func New(iface string) *Goshark {
	return &Goshark{
		Interface: iface,
		Count:     10, // 默认抓10个包
		Fields: []string{
			"frame.time",
			"ip.src",
			"ip.dst",
			"ip.proto",
			"frame.len",
			"_ws.col.info",
		},
	}
}

// Capture 执行抓包并解码
func (g *Goshark) Capture() ([]Packet, error) {
	// 构建tshark命令
	args := []string{
		"-i", g.Interface,
		"-c", fmt.Sprintf("%d", g.Count),
		"-T", "json",
		"-e", strings.Join(g.Fields, ","),
	}

	if g.Filter != "" {
		args = append(args, "-f", g.Filter)
	}

	cmd := exec.Command("tshark", args...)
	var out bytes.Buffer
	cmd.Stdout = &out

	// 执行命令
	if err := cmd.Run(); err != nil {
		return nil, fmt.Errorf("tshark执行失败: %v", err)
	}

	// 解析JSON输出
	var rawPackets []map[string]interface{}
	if err := json.Unmarshal(out.Bytes(), &rawPackets); err != nil {
		return nil, fmt.Errorf("解析JSON失败: %v", err)
	}

	// 转换为Packet结构
	var packets []Packet
	for _, raw := range rawPackets {
		layers, ok := raw["_source"].(map[string]interface{})
		if !ok {
			continue
		}

		packet := Packet{
			Timestamp:   getString(layers, "frame.time"),
			Source:      getString(layers, "ip.src"),
			Destination: getString(layers, "ip.dst"),
			Protocol:    getString(layers, "ip.proto"),
			Length:      getInt(layers, "frame.len"),
			Info:        getString(layers, "_ws.col.info"),
			Layers:      layers,
		}

		packets = append(packets, packet)
	}

	return packets, nil
}

// getString 从map中安全获取字符串值
func getString(m map[string]interface{}, key string) string {
	if val, ok := m[key]; ok {
		if str, ok := val.(string); ok {
			return str
		}
	}
	return ""
}

// getInt 从map中安全获取整数值
func getInt(m map[string]interface{}, key string) int {
	if val, ok := m[key]; ok {
		switch v := val.(type) {
		case string:
			var i int
			fmt.Sscanf(v, "%d", &i)
			return i
		case float64:
			return int(v)
		}
	}
	return 0
}

// AnalyzeProtocolDistribution 分析协议分布
func (g *Goshark) AnalyzeProtocolDistribution(packets []Packet) map[string]int {
	distribution := make(map[string]int)
	for _, p := range packets {
		if p.Protocol != "" {
			distribution[p.Protocol]++
		}
	}
	return distribution
}

使用示例

package main

import (
	"fmt"
	"log"

	"github.com/yourusername/goshark"
)

func main() {
	// 创建goshark实例
	gs := goshark.New("eth0") // 替换为你的网络接口
	gs.Filter = "ip"          // 只抓取IP数据包
	gs.Count = 5              // 抓取5个包

	// 执行抓包
	packets, err := gs.Capture()
	if err != nil {
		log.Fatal(err)
	}

	// 打印抓包结果
	for i, p := range packets {
		fmt.Printf("Packet #%d:\n", i+1)
		fmt.Printf("  Time: %s\n", p.Timestamp)
		fmt.Printf("  Source: %s -> Destination: %s\n", p.Source, p.Destination)
		fmt.Printf("  Protocol: %s, Length: %d\n", p.Protocol, p.Length)
		fmt.Printf("  Info: %s\n", p.Info)
		fmt.Println("----------------------------------------")
	}

	// 分析协议分布
	dist := gs.AnalyzeProtocolDistribution(packets)
	fmt.Println("\nProtocol Distribution:")
	for proto, count := range dist {
		fmt.Printf("  %s: %d packets\n", proto, count)
	}
}

功能扩展建议

1. 实时抓包模式：添加持续抓包功能而不是只抓固定数量的包
2. 深度包解析：支持解析更多协议层(TCP/UDP/HTTP等)
3. 统计分析：添加流量统计、异常检测等功能
4. 输出格式：支持多种输出格式(CSV、文本表格等)
5. 过滤功能：增强过滤条件支持

注意事项

1. 使用前需要安装tshark/Wireshark
2. 可能需要root权限才能抓包
3. 不同版本的tshark可能有不同的输出格式

这个实现提供了基本的网络抓包和解码功能，你可以根据需要进一步扩展和完善它。