github.com/gopacket/gopacket@v1.1.0/layers/tcpip_test.go (about)

     1  // Copyright 2014, Google, Inc. All rights reserved.
     2  //
     3  // Use of this source code is governed by a BSD-style license
     4  // that can be found in the LICENSE file in the root of the source
     5  // tree.
     6  
     7  package layers
     8  
     9  import (
    10  	"net"
    11  	"testing"
    12  
    13  	"github.com/gopacket/gopacket"
    14  )
    15  
    16  const (
    17  	ipv4UDPChecksum                = uint16(0xbc5f) // Wireshark
    18  	ipv6UDPChecksumWithIPv6DstOpts = uint16(0x4d21) // Wireshark
    19  	ipv6UDPChecksumJumbogram       = uint16(0xcda8)
    20  )
    21  
    22  func createIPv4ChecksumTestLayer() (ip4 *IPv4) {
    23  	ip4 = &IPv4{}
    24  	ip4.Version = 4
    25  	ip4.TTL = 64
    26  	ip4.SrcIP = net.ParseIP("192.0.2.1")
    27  	ip4.DstIP = net.ParseIP("198.51.100.1")
    28  	return
    29  }
    30  
    31  func createIPv6ChecksumTestLayer() (ip6 *IPv6) {
    32  	ip6 = &IPv6{}
    33  	ip6.Version = 6
    34  	ip6.NextHeader = IPProtocolNoNextHeader
    35  	ip6.HopLimit = 64
    36  	ip6.SrcIP = net.ParseIP("2001:db8::1")
    37  	ip6.DstIP = net.ParseIP("2001:db8::2")
    38  	return
    39  }
    40  
    41  func createIPv6DestinationChecksumTestLayer() (dst *IPv6Destination) {
    42  	tlv := &IPv6DestinationOption{}
    43  	tlv.OptionType = 0x01 //PadN
    44  	tlv.OptionData = []byte{0x00, 0x00, 0x00, 0x00}
    45  	dst = &IPv6Destination{}
    46  	dst.Options = append(dst.Options, tlv)
    47  	dst.NextHeader = IPProtocolNoNextHeader
    48  	return
    49  }
    50  
    51  func createUDPChecksumTestLayer() (udp *UDP) {
    52  	udp = &UDP{}
    53  	udp.SrcPort = UDPPort(12345)
    54  	udp.DstPort = UDPPort(9999)
    55  	return
    56  }
    57  
    58  func TestIPv4UDPChecksum(t *testing.T) {
    59  	var serialize = make([]gopacket.SerializableLayer, 0, 2)
    60  	var u *UDP
    61  	var err error
    62  
    63  	ip4 := createIPv4ChecksumTestLayer()
    64  	ip4.Protocol = IPProtocolUDP
    65  	serialize = append(serialize, ip4)
    66  
    67  	udp := createUDPChecksumTestLayer()
    68  	udp.SetNetworkLayerForChecksum(ip4)
    69  	serialize = append(serialize, udp)
    70  
    71  	buf := gopacket.NewSerializeBuffer()
    72  	opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
    73  	err = gopacket.SerializeLayers(buf, opts, serialize...)
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  
    78  	p := gopacket.NewPacket(buf.Bytes(), LinkTypeRaw, gopacket.Default)
    79  	if p.ErrorLayer() != nil {
    80  		t.Fatal("Failed to decode packet:", p.ErrorLayer().Error())
    81  	}
    82  	checkLayers(p, []gopacket.LayerType{LayerTypeIPv4, LayerTypeUDP}, t)
    83  
    84  	if l, ok := p.Layer(LayerTypeUDP).(*UDP); !ok {
    85  		t.Fatal("No UDP layer type found in packet")
    86  	} else {
    87  		u = l
    88  	}
    89  	got := u.Checksum
    90  	want := ipv4UDPChecksum
    91  	if got != want {
    92  		t.Errorf("Bad checksum:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
    93  	}
    94  }
    95  
    96  func TestIPv6UDPChecksumWithIPv6DstOpts(t *testing.T) {
    97  	var serialize = make([]gopacket.SerializableLayer, 0, 3)
    98  	var u *UDP
    99  	var err error
   100  
   101  	ip6 := createIPv6ChecksumTestLayer()
   102  	ip6.NextHeader = IPProtocolIPv6Destination
   103  	serialize = append(serialize, ip6)
   104  
   105  	dst := createIPv6DestinationChecksumTestLayer()
   106  	dst.NextHeader = IPProtocolUDP
   107  	serialize = append(serialize, dst)
   108  
   109  	udp := createUDPChecksumTestLayer()
   110  	udp.SetNetworkLayerForChecksum(ip6)
   111  	serialize = append(serialize, udp)
   112  
   113  	buf := gopacket.NewSerializeBuffer()
   114  	opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
   115  	err = gopacket.SerializeLayers(buf, opts, serialize...)
   116  	if err != nil {
   117  		t.Fatal(err)
   118  	}
   119  
   120  	p := gopacket.NewPacket(buf.Bytes(), LinkTypeRaw, gopacket.Default)
   121  	if p.ErrorLayer() != nil {
   122  		t.Fatal("Failed to decode packet:", p.ErrorLayer().Error())
   123  	}
   124  	checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6Destination, LayerTypeUDP}, t)
   125  
   126  	if l, ok := p.Layer(LayerTypeUDP).(*UDP); !ok {
   127  		t.Fatal("No UDP layer type found in packet")
   128  	} else {
   129  		u = l
   130  	}
   131  	got := u.Checksum
   132  	want := ipv6UDPChecksumWithIPv6DstOpts
   133  	if got != want {
   134  		t.Errorf("Bad checksum:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
   135  	}
   136  }
   137  
   138  func TestIPv6JumbogramUDPChecksum(t *testing.T) {
   139  	var serialize = make([]gopacket.SerializableLayer, 0, 4)
   140  	var u *UDP
   141  	var err error
   142  
   143  	ip6 := &IPv6{}
   144  	ip6.Version = 6
   145  	ip6.NextHeader = IPProtocolUDP
   146  	ip6.HopLimit = 64
   147  	ip6.SrcIP = net.ParseIP("2001:db8::1")
   148  	ip6.DstIP = net.ParseIP("2001:db8::2")
   149  	serialize = append(serialize, ip6)
   150  
   151  	udp := &UDP{}
   152  	udp.SrcPort = UDPPort(12345)
   153  	udp.DstPort = UDPPort(9999)
   154  	udp.SetNetworkLayerForChecksum(ip6)
   155  	serialize = append(serialize, udp)
   156  
   157  	payload := make([]byte, ipv6MaxPayloadLength+1)
   158  	for i := range payload {
   159  		payload[i] = 0xfe
   160  	}
   161  	serialize = append(serialize, gopacket.Payload(payload))
   162  
   163  	buf := gopacket.NewSerializeBuffer()
   164  	opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
   165  	err = gopacket.SerializeLayers(buf, opts, serialize...)
   166  	if err != nil {
   167  		t.Fatal(err)
   168  	}
   169  
   170  	p := gopacket.NewPacket(buf.Bytes(), LinkTypeRaw, gopacket.Default)
   171  	if p.ErrorLayer() != nil {
   172  		t.Fatal("Failed to decode packet:", p.ErrorLayer().Error())
   173  	}
   174  	checkLayers(p, []gopacket.LayerType{LayerTypeIPv6, LayerTypeIPv6HopByHop, LayerTypeUDP, gopacket.LayerTypePayload}, t)
   175  
   176  	if l, ok := p.Layer(LayerTypeUDP).(*UDP); !ok {
   177  		t.Fatal("No UDP layer type found in packet")
   178  	} else {
   179  		u = l
   180  	}
   181  	got := u.Checksum
   182  	want := ipv6UDPChecksumJumbogram
   183  	if got != want {
   184  		t.Errorf("Bad checksum:\ngot:\n%#v\n\nwant:\n%#v\n\n", got, want)
   185  	}
   186  }