解析IP-in-IP数据包上的Gopacket DecodeLayers

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《解析IP-in-IP数据包上的Gopacket DecodeLayers》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

如果我有数据通过 decodinglayerparser 并且其中一些数据可能包含 ip 协议 4 (ip-in-ip) 数据包，我如何让它捕获数据包中的两个 ipv4 标头？我似乎只能用它来捕捉其中的一个。

type Decoder struct {
    eth   layers.Ethernet
    ip4   layers.IPv4
    ipip4 layers.IPv4
    ip6   layers.IPv6
    icmp4 layers.ICMPv4
    icmp6 layers.ICMPv6
    tcp   layers.TCP
    udp   layers.UDP
    //sip      layers.SIP
    //dns      layers.DNS
    //ntp      layers.NTP
    pay      gopacket.Payload
    parser   *gopacket.DecodingLayerParser
    types    []gopacket.LayerType
    unknowns map[string]uint
}

// NewDecoder allocates and initialises a new Decoder.
func NewDecoder() *Decoder {
    d := new(Decoder)
    d.parser = gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet,
        &d.eth, &d.ip4, &d.ipip4, &d.ip6, &d.icmp4, &d.icmp6, &d.tcp, &d.udp, &d.pay)
    //&d.sip, &d.dns, &d.ntp, &d.pay)
    d.types = make([]gopacket.LayerType, 10, 10)
    d.parser.IgnoreUnsupported = true
    d.unknowns = make(map[string]uint)
    return d
}

当从解析器调用 decodelayers 时，我如何修改它才能做到这一点？它似乎只在 ipip4 中存储第二个 ipv4 标头的信息。

正确答案

为什么不起作用

接口 decodinglayercontainer 旨在通过其 layertype 索引 decodinglayer（请参阅 解码器（layertype）（decodinglayer，bool））。由于ip4和ipip4具有相同的layertype（layers.layertypeipv4），因此后者在容器中会覆盖前者。每次 decodinglayerparser 从 layers.layertypeipv4 的容器获取解码器时，它都会获取 ipip4。所以ipip4的状态会一次又一次的改变。

解决方法

解决方法是为 ip4 和 ipip4 提供不同的 layertype。当数据包是ip数据包中的ip时，使ip4选择ipip4作为其下一个解码器。这是演示：

package main

import (
    "fmt"
    "io"

    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"
)

// 0-999 are reserved for the gopacket library. numbers 1000-1999 should be
// used for common application-specific types.
var layertypeipv4inner = gopacket.registerlayertype(1000, gopacket.layertypemetadata{name: "ip_in_ip", decoder: nil})

// ipv4outer is like layers.ipv4 but it recognizes ip in ip and will choose
// its next decoder accordingly.
type ipv4outer struct {
    layers.ipv4
}

// nextlayertype overrides (*layers.ipv4).nextlayertype to recognize ip in ip.
func (i *ipv4outer) nextlayertype() gopacket.layertype {
    if i.flags&layers.ipv4morefragments != 0 || i.fragoffset != 0 {
        return gopacket.layertypefragment
    }
    // this is an ip in ip packet.
    // see https://datatracker.ietf.org/doc/html/rfc2003#section-3.1
    if i.protocol == 4 {
        return layertypeipv4inner
    }
    return i.protocol.layertype()
}

// ipv4inner is like layers.ipv4 except that its type is layertypeipv4inner.
// gopacket.decodinglayerparser finds next decoder based on this type.
type ipv4inner struct {
    layers.ipv4
}

// candecode overrides (*layers.ipv4).candecode to choose a type other than
// layers.layertypeipv4.
func (i *ipv4inner) candecode() gopacket.layerclass {
    return layertypeipv4inner
}

func main() {
    handle, err := pcap.openoffline("./ip_in_ip.cap")
    if err != nil {
        panic(err)
    }

    var (
        eth     layers.ethernet
        ip4     ipv4outer
        ipip4   ipv4inner
        tcp     layers.tcp
        icmpv4  layers.icmpv4
        payload gopacket.payload
    )
    parser := gopacket.newdecodinglayerparser(layers.layertypeethernet, &eth, &ip4, &ipip4, &tcp, &icmpv4, &payload)
    decodedlayers := make([]gopacket.layertype, 0, 10)
    for {
        data, _, err := handle.zerocopyreadpacketdata()
        if err == io.eof {
            fmt.println("done")
            return
        }

        if err != nil {
            panic(err)
        }

        err = parser.decodelayers(data, &decodedlayers)
        if err != nil {
            panic(err)
        }

        for _, typ := range decodedlayers {
            if typ == layers.layertypeipv4 {
                fmt.printf("ipv4: %s => %s\n", ip4.srcip, ip4.dstip)
            } else if typ == layertypeipv4inner {
                fmt.printf("ip in ip: %s => %s\n", ipip4.srcip, ipip4.dstip)
            }
        }

        fmt.printf("%v\n\n", decodedlayers)
    }
}

我已经使用 https://packetlife.net/media/captures/ip_in_ip.cap 进行了测试 和 gopacket 中的 test_ethernet.pcap。输出如下所示：

Ipv4: 10.0.0.1 => 10.0.0.2
IP in IP: 1.1.1.1 => 2.2.2.2
[Ethernet IPv4 IP_in_IP ICMPv4 Payload]

Ipv4: 10.0.0.2 => 10.0.0.1
IP in IP: 2.2.2.2 => 1.1.1.1
[Ethernet IPv4 IP_in_IP ICMPv4 Payload]

Ipv4: 10.1.1.2 => 10.1.1.1
[Ethernet IPv4 TCP]

Ipv4: 10.1.1.1 => 10.1.1.2
[Ethernet IPv4 TCP]

注释

1. decodinglayerparser 速度更快，但也更严格。虽然 packetsource 速度较慢，但​​它将安全且轻松地处理任何已知类型的数据包。 （我相信您已经知道这一点）。
2. 这只是一种解决方法。我不确定这是否是最佳实践。
3. 该演示的目的是说明解决此类问题的想法。它不适用于数据包具有多个 ipv4 标头的其他情况。例如，它无法正确解析此文件： https://packetlife.net/media/captures /gre.cap。我们知道 decodinglayerparser 是严格的，我们必须自己处理其他极端情况。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。