Finish porting to ONF infrastructure
- change of imports
- Adding vendor folder
- licensing
Change-Id: If2e7ed27d603668b848ae58c135e94a8db13a9e2
diff --git a/vendor/github.com/google/gopacket/layers/eapol.go b/vendor/github.com/google/gopacket/layers/eapol.go
new file mode 100644
index 0000000..12aa5ba
--- /dev/null
+++ b/vendor/github.com/google/gopacket/layers/eapol.go
@@ -0,0 +1,298 @@
+// Copyright 2012 Google, Inc. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree.
+
+package layers
+
+import (
+ "encoding/binary"
+ "fmt"
+ "github.com/google/gopacket"
+)
+
+// EAPOL defines an EAP over LAN (802.1x) layer.
+type EAPOL struct {
+ BaseLayer
+ Version uint8
+ Type EAPOLType
+ Length uint16
+}
+
+// LayerType returns LayerTypeEAPOL.
+func (e *EAPOL) LayerType() gopacket.LayerType { return LayerTypeEAPOL }
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (e *EAPOL) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ e.Version = data[0]
+ e.Type = EAPOLType(data[1])
+ e.Length = binary.BigEndian.Uint16(data[2:4])
+ e.BaseLayer = BaseLayer{data[:4], data[4:]}
+ return nil
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer
+func (e *EAPOL) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ bytes, _ := b.PrependBytes(4)
+ bytes[0] = e.Version
+ bytes[1] = byte(e.Type)
+ binary.BigEndian.PutUint16(bytes[2:], e.Length)
+ return nil
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (e *EAPOL) CanDecode() gopacket.LayerClass {
+ return LayerTypeEAPOL
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (e *EAPOL) NextLayerType() gopacket.LayerType {
+ return e.Type.LayerType()
+}
+
+func decodeEAPOL(data []byte, p gopacket.PacketBuilder) error {
+ e := &EAPOL{}
+ return decodingLayerDecoder(e, data, p)
+}
+
+// EAPOLKeyDescriptorType is an enumeration of key descriptor types
+// as specified by 802.1x in the EAPOL-Key frame
+type EAPOLKeyDescriptorType uint8
+
+// Enumeration of EAPOLKeyDescriptorType
+const (
+ EAPOLKeyDescriptorTypeRC4 EAPOLKeyDescriptorType = 1
+ EAPOLKeyDescriptorTypeDot11 EAPOLKeyDescriptorType = 2
+ EAPOLKeyDescriptorTypeWPA EAPOLKeyDescriptorType = 254
+)
+
+func (kdt EAPOLKeyDescriptorType) String() string {
+ switch kdt {
+ case EAPOLKeyDescriptorTypeRC4:
+ return "RC4"
+ case EAPOLKeyDescriptorTypeDot11:
+ return "802.11"
+ case EAPOLKeyDescriptorTypeWPA:
+ return "WPA"
+ default:
+ return fmt.Sprintf("unknown descriptor type %d", kdt)
+ }
+}
+
+// EAPOLKeyDescriptorVersion is an enumeration of versions specifying the
+// encryption algorithm for the key data and the authentication for the
+// message integrity code (MIC)
+type EAPOLKeyDescriptorVersion uint8
+
+// Enumeration of EAPOLKeyDescriptorVersion
+const (
+ EAPOLKeyDescriptorVersionOther EAPOLKeyDescriptorVersion = 0
+ EAPOLKeyDescriptorVersionRC4HMACMD5 EAPOLKeyDescriptorVersion = 1
+ EAPOLKeyDescriptorVersionAESHMACSHA1 EAPOLKeyDescriptorVersion = 2
+ EAPOLKeyDescriptorVersionAES128CMAC EAPOLKeyDescriptorVersion = 3
+)
+
+func (v EAPOLKeyDescriptorVersion) String() string {
+ switch v {
+ case EAPOLKeyDescriptorVersionOther:
+ return "Other"
+ case EAPOLKeyDescriptorVersionRC4HMACMD5:
+ return "RC4-HMAC-MD5"
+ case EAPOLKeyDescriptorVersionAESHMACSHA1:
+ return "AES-HMAC-SHA1-128"
+ case EAPOLKeyDescriptorVersionAES128CMAC:
+ return "AES-128-CMAC"
+ default:
+ return fmt.Sprintf("unknown version %d", v)
+ }
+}
+
+// EAPOLKeyType is an enumeration of key derivation types describing
+// the purpose of the keys being derived.
+type EAPOLKeyType uint8
+
+// Enumeration of EAPOLKeyType
+const (
+ EAPOLKeyTypeGroupSMK EAPOLKeyType = 0
+ EAPOLKeyTypePairwise EAPOLKeyType = 1
+)
+
+func (kt EAPOLKeyType) String() string {
+ switch kt {
+ case EAPOLKeyTypeGroupSMK:
+ return "Group/SMK"
+ case EAPOLKeyTypePairwise:
+ return "Pairwise"
+ default:
+ return fmt.Sprintf("unknown key type %d", kt)
+ }
+}
+
+// EAPOLKey defines an EAPOL-Key frame for 802.1x authentication
+type EAPOLKey struct {
+ BaseLayer
+ KeyDescriptorType EAPOLKeyDescriptorType
+ KeyDescriptorVersion EAPOLKeyDescriptorVersion
+ KeyType EAPOLKeyType
+ KeyIndex uint8
+ Install bool
+ KeyACK bool
+ KeyMIC bool
+ Secure bool
+ MICError bool
+ Request bool
+ HasEncryptedKeyData bool
+ SMKMessage bool
+ KeyLength uint16
+ ReplayCounter uint64
+ Nonce []byte
+ IV []byte
+ RSC uint64
+ ID uint64
+ MIC []byte
+ KeyDataLength uint16
+ EncryptedKeyData []byte
+}
+
+// LayerType returns LayerTypeEAPOLKey.
+func (ek *EAPOLKey) LayerType() gopacket.LayerType {
+ return LayerTypeEAPOLKey
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (ek *EAPOLKey) CanDecode() gopacket.LayerType {
+ return LayerTypeEAPOLKey
+}
+
+// NextLayerType returns layers.LayerTypeDot11InformationElement if the key
+// data exists and is unencrypted, otherwise it does not expect a next layer.
+func (ek *EAPOLKey) NextLayerType() gopacket.LayerType {
+ if !ek.HasEncryptedKeyData && ek.KeyDataLength > 0 {
+ return LayerTypeDot11InformationElement
+ }
+ return gopacket.LayerTypePayload
+}
+
+const eapolKeyFrameLen = 95
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (ek *EAPOLKey) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ if len(data) < eapolKeyFrameLen {
+ df.SetTruncated()
+ return fmt.Errorf("EAPOLKey length %v too short, %v required",
+ len(data), eapolKeyFrameLen)
+ }
+
+ ek.KeyDescriptorType = EAPOLKeyDescriptorType(data[0])
+
+ info := binary.BigEndian.Uint16(data[1:3])
+ ek.KeyDescriptorVersion = EAPOLKeyDescriptorVersion(info & 0x0007)
+ ek.KeyType = EAPOLKeyType((info & 0x0008) >> 3)
+ ek.KeyIndex = uint8((info & 0x0030) >> 4)
+ ek.Install = (info & 0x0040) != 0
+ ek.KeyACK = (info & 0x0080) != 0
+ ek.KeyMIC = (info & 0x0100) != 0
+ ek.Secure = (info & 0x0200) != 0
+ ek.MICError = (info & 0x0400) != 0
+ ek.Request = (info & 0x0800) != 0
+ ek.HasEncryptedKeyData = (info & 0x1000) != 0
+ ek.SMKMessage = (info & 0x2000) != 0
+
+ ek.KeyLength = binary.BigEndian.Uint16(data[3:5])
+ ek.ReplayCounter = binary.BigEndian.Uint64(data[5:13])
+
+ ek.Nonce = data[13:45]
+ ek.IV = data[45:61]
+ ek.RSC = binary.BigEndian.Uint64(data[61:69])
+ ek.ID = binary.BigEndian.Uint64(data[69:77])
+ ek.MIC = data[77:93]
+
+ ek.KeyDataLength = binary.BigEndian.Uint16(data[93:95])
+
+ totalLength := eapolKeyFrameLen + int(ek.KeyDataLength)
+ if len(data) < totalLength {
+ df.SetTruncated()
+ return fmt.Errorf("EAPOLKey data length %d too short, %d required",
+ len(data)-eapolKeyFrameLen, ek.KeyDataLength)
+ }
+
+ if ek.HasEncryptedKeyData {
+ ek.EncryptedKeyData = data[eapolKeyFrameLen:totalLength]
+ ek.BaseLayer = BaseLayer{
+ Contents: data[:totalLength],
+ Payload: data[totalLength:],
+ }
+ } else {
+ ek.BaseLayer = BaseLayer{
+ Contents: data[:eapolKeyFrameLen],
+ Payload: data[eapolKeyFrameLen:],
+ }
+ }
+
+ return nil
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (ek *EAPOLKey) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ buf, err := b.PrependBytes(eapolKeyFrameLen + len(ek.EncryptedKeyData))
+ if err != nil {
+ return err
+ }
+
+ buf[0] = byte(ek.KeyDescriptorType)
+
+ var info uint16
+ info |= uint16(ek.KeyDescriptorVersion)
+ info |= uint16(ek.KeyType) << 3
+ info |= uint16(ek.KeyIndex) << 4
+ if ek.Install {
+ info |= 0x0040
+ }
+ if ek.KeyACK {
+ info |= 0x0080
+ }
+ if ek.KeyMIC {
+ info |= 0x0100
+ }
+ if ek.Secure {
+ info |= 0x0200
+ }
+ if ek.MICError {
+ info |= 0x0400
+ }
+ if ek.Request {
+ info |= 0x0800
+ }
+ if ek.HasEncryptedKeyData {
+ info |= 0x1000
+ }
+ if ek.SMKMessage {
+ info |= 0x2000
+ }
+ binary.BigEndian.PutUint16(buf[1:3], info)
+
+ binary.BigEndian.PutUint16(buf[3:5], ek.KeyLength)
+ binary.BigEndian.PutUint64(buf[5:13], ek.ReplayCounter)
+
+ copy(buf[13:45], ek.Nonce)
+ copy(buf[45:61], ek.IV)
+ binary.BigEndian.PutUint64(buf[61:69], ek.RSC)
+ binary.BigEndian.PutUint64(buf[69:77], ek.ID)
+ copy(buf[77:93], ek.MIC)
+
+ binary.BigEndian.PutUint16(buf[93:95], ek.KeyDataLength)
+ if len(ek.EncryptedKeyData) > 0 {
+ copy(buf[95:95+len(ek.EncryptedKeyData)], ek.EncryptedKeyData)
+ }
+
+ return nil
+}
+
+func decodeEAPOLKey(data []byte, p gopacket.PacketBuilder) error {
+ ek := &EAPOLKey{}
+ return decodingLayerDecoder(ek, data, p)
+}