基于Go实现网卡与应用间流量GRE封装/解封装的技术咨询

一、先明确核心问题：当前代码的局限性 #

你现在写的是TCP端口转发代理，只能处理特定TCP端口的流量，完全无法实现网卡与应用间的全量IP层流量拦截，更没法处理GRE封装/解封装。必须从技术选型上调整，转向IP层的数据包捕获与处理。

二、技术选型方向 #

推荐方案1：使用gopacket库处理raw socket #

gopacket是Golang生态中成熟的数据包解析/构造库，支持通过raw socket或pcap捕获网卡流量，能轻松解析IP、GRE等协议层。

备选方案2：使用eBPF（通过cilium/ebpf库） #

如果需要更高性能的流量拦截（尤其是本地应用与网卡间的流量），eBPF是更优选择，它能在内核态直接过滤和修改流量，避免用户态拷贝开销。

三、核心业务逻辑拆解 #

1. 接收方向（网卡→应用） #

• 捕获网卡上来自特定IP的IP数据包，过滤出带有GRE头部的流量
• 解析GRE头部，剥离外层封装，取出内层IP数据包
• 将内层数据包转发到目标本地应用：
  • 若内层是TCP/UDP流量，可解析端口后转发到应用的监听端口；
  • 也可通过raw socket将内层数据包注入到本地协议栈，让应用直接接收。

2. 发送方向（应用→网卡） #

• 捕获本地应用发往网卡的IP数据包
• 构造GRE头部（遵循RFC 2784标准），将原始IP数据包作为内层负载
• 封装外层IP头部，指定目的IP为你的特定IP，然后发送到网卡

四、基于gopacket的改造示例 #

以下是核心逻辑的代码框架，你可以在此基础上完善：

package main

import (
	"fmt"
	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/google/gopacket/pcap"
	"net"
)

const (
	deviceName     = "eth0"       // 替换为你的实际网卡名称
	targetGREIP    = "10.10.1.1"  // 指定的GRE通信IP
	localIP        = "192.168.1.100" // 你的本地网卡IP
	snapLen        = 65535
	promiscuous    = true
	timeout        = pcap.BlockForever
)

func main() {
	// 打开网卡捕获流量，需要root权限
	handle, err := pcap.OpenLive(deviceName, snapLen, promiscuous, timeout)
	if err != nil {
		panic(fmt.Sprintf("打开网卡失败: %v", err))
	}
	defer handle.Close()

	// 设置BPF过滤规则：捕获来自目标IP的GRE流量，以及本地发往外部的IP流量
	filter := fmt.Sprintf("src host %s and proto gre or (src host %s and proto ip)", targetGREIP, localIP)
	if err := handle.SetBPFFilter(filter); err != nil {
		panic(fmt.Sprintf("设置过滤规则失败: %v", err))
	}

	// 持续处理捕获的数据包
	packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
	for pkt := range packetSource.Packets() {
		go processPacket(pkt)
	}
}

func processPacket(pkt gopacket.Packet) {
	// 解析外层IP层
	outerIP, ok := pkt.Layer(layers.LayerTypeIPv4).(*layers.IPv4)
	if !ok {
		return
	}

	// 处理来自目标IP的GRE数据包（解封装）
	if outerIP.SrcIP.String() == targetGREIP {
		greLayer, ok := pkt.Layer(layers.LayerTypeGRE).(*layers.GRE)
		if !ok {
			return
		}
		// 解析内层IP数据包
		innerPkt := gopacket.NewPacket(greLayer.Payload, layers.LayerTypeIPv4, gopacket.Default)
		// 将内层数据包转发到本地应用，这里示例为发送到回环接口
		forwardToLocal(innerPkt)
		return
	}

	// 处理本地应用发往外部的流量（封装GRE）
	if outerIP.SrcIP.String() == localIP {
		// 构造GRE头部
		gre := &layers.GRE{
			Protocol: layers.EthernetTypeIPv4, // 内层为IPv4协议
		}
		// 构造外层IP头部
		newOuterIP := &layers.IPv4{
			SrcIP:    net.ParseIP(localIP),
			DstIP:    net.ParseIP(targetGREIP),
			Protocol: layers.IPProtocolGRE,
			TTL:      64,
		}
		// 序列化数据包（自动计算校验和与长度）
		buf := gopacket.NewSerializeBuffer()
		opts := gopacket.SerializeOptions{
			FixLengths:       true,
			ComputeChecksums: true,
		}
		if err := gopacket.SerializeLayers(buf, opts, newOuterIP, gre, gopacket.Payload(outerIP.Payload)); err != nil {
			fmt.Printf("序列化数据包失败: %v\n", err)
			return
		}
		// 发送封装后的数据包到网卡
		sendToNetwork(buf.Bytes())
	}
}

func forwardToLocal(pkt gopacket.Packet) {
	// 这里可以实现将内层数据包转发到本地应用的逻辑：
	// 1. 解析内层TCP/UDP端口，通过端口转发到应用监听端口；
	// 2. 或者通过raw socket将数据包注入到本地协议栈。
	// 示例：打印内层数据包信息
	if innerIP, ok := pkt.Layer(layers.LayerTypeIPv4).(*layers.IPv4); ok {
		fmt.Printf("解封装后内层IP: %s → %s\n", innerIP.SrcIP, innerIP.DstIP)
	}
}

func sendToNetwork(data []byte) {
	// 打开raw socket发送GRE封装后的数据包
	conn, err := net.ListenPacket("ip4:gre", "0.0.0.0")
	if err != nil {
		fmt.Printf("打开raw socket失败: %v\n", err)
		return
	}
	defer conn.Close()
	_, err = conn.WriteTo(data, &net.IPAddr{IP: net.ParseIP(targetGREIP)})
	if err != nil {
		fmt.Printf("发送数据包失败: %v\n", err)
	}
}

五、关键注意事项 #

• 必须以root权限运行程序，因为raw socket和网卡捕获需要系统特权；
• 本地回环流量（127.0.0.1）的捕获需要特殊处理，raw socket默认无法捕获，可改用eBPF或调整系统参数；
• 要确保数据包的校验和、TTL等字段正确，gopacket的SerializeOptions可自动处理大部分计算；
• 若需要对接特定应用，需实现内层数据包到应用端口的转发逻辑，可结合TCP/UDP代理的思路补充。

内容的提问来源于stack exchange，提问作者amb1s1