WireGuardLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "IpAddress.h"
#include "MacAddress.h"
 
 
namespace pcpp
{
    class WireGuardLayer : public Layer
    {
    protected:
#pragma pack(push, 1)
        struct wg_common_header
        {
            uint8_t messageType;
            uint8_t reserved[3];
        };
#pragma pack(pop)
        static_assert(sizeof(wg_common_header) == 4, "wg_common_header size is not 4 bytes");
 
        wg_common_header* getBasicHeader() const
        {
            return reinterpret_cast<wg_common_header*>(m_Data);
        }
 
        WireGuardLayer() = default;
 
    public:
        enum class WireGuardMessageType
        {
            Unknown = 0,
            HandshakeInitiation = 1,
            HandshakeResponse = 2,
            CookieReply = 3,
            TransportData = 4
        };
 
        WireGuardLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, WireGuard)
        {}
 
        static bool isWireGuardPorts(uint16_t portSrc, uint16_t portDst)
        {
            return (portSrc == 51820 || portDst == 51820);
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        static WireGuardLayer* parseWireGuardLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        std::string getMessageTypeAsString() const;
 
        uint8_t getMessageType() const;
 
        uint32_t getReserved() const;
 
        void setReserved(const std::array<uint8_t, 3>& reserved);
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override;
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
 
        virtual WireGuardMessageType getWireGuardMessageType() const
        {
            return WireGuardMessageType::Unknown;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ MessageType, MessageTypeName };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor MessageType;
 
            static const FieldDescriptor MessageTypeName;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 2;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class WireGuardHandshakeInitiationLayer : public WireGuardLayer
    {
    private:
#pragma pack(push, 1)
        typedef struct wg_handshake_initiation : wg_common_header
        {
            uint32_t senderIndex;
            uint8_t initiatorEphemeral[32];
            uint8_t encryptedInitiatorStatic[48];
            uint8_t encryptedTimestamp[28];
            uint8_t mac1[16];
            uint8_t mac2[16];
        } wg_handshake_initiation;
#pragma pack(pop)
        wg_handshake_initiation* getHandshakeInitiationHeader() const
        {
            return reinterpret_cast<wg_handshake_initiation*>(getBasicHeader());
        }
 
    public:
        WireGuardHandshakeInitiationLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : WireGuardLayer(data, dataLen, prevLayer, packet)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(wg_handshake_initiation);
        }
 
        WireGuardHandshakeInitiationLayer(uint32_t senderIndex, const uint8_t initiatorEphemeral[32],
                                          const uint8_t encryptedInitiatorStatic[48],
                                          const uint8_t encryptedTimestamp[28], const uint8_t mac1[16],
                                          const uint8_t mac2[16]);
 
        uint32_t getSenderIndex() const;
 
        std::array<uint8_t, 32> getInitiatorEphemeral() const;
 
        std::array<uint8_t, 48> getEncryptedInitiatorStatic() const;
 
        std::array<uint8_t, 28> getEncryptedTimestamp() const;
 
        std::array<uint8_t, 16> getMac1() const;
 
        std::array<uint8_t, 16> getMac2() const;
 
        void setSenderIndex(uint32_t senderIndex);
 
        void setInitiatorEphemeral(const std::array<uint8_t, 32>& initiatorEphemeral);
 
        void setEncryptedInitiatorStatic(const std::array<uint8_t, 48>& encryptedInitiatorStatic);
 
        void setEncryptedTimestamp(const std::array<uint8_t, 28>& encryptedTimestamp);
 
        void setMac1(const std::array<uint8_t, 16>& mac1);
 
        void setMac2(const std::array<uint8_t, 16>& mac2);
 
        // implement abstract methods
 
        WireGuardMessageType getWireGuardMessageType() const override
        {
            return WireGuardMessageType::HandshakeInitiation;
        }
 
        struct SerializedFields : WireGuardLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = WireGuardLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{
                    SenderIndex, InitiatorEphemeral, EncryptedInitiatorStatic, EncryptedTimestamp, Mac1, Mac2
                };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor SenderIndex;
 
            static const FieldDescriptor InitiatorEphemeral;
 
            static const FieldDescriptor EncryptedInitiatorStatic;
 
            static const FieldDescriptor EncryptedTimestamp;
 
            static const FieldDescriptor Mac1;
 
            static const FieldDescriptor Mac2;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class WireGuardHandshakeResponseLayer : public WireGuardLayer
    {
    private:
#pragma pack(push, 1)
        typedef struct wg_handshake_response : wg_common_header
        {
            uint32_t senderIndex;
            uint32_t receiverIndex;
            uint8_t responderEphemeral[32];
            uint8_t encryptedEmpty[16];
            uint8_t mac1[16];
            uint8_t mac2[16];
        } wg_handshake_response;
#pragma pack(pop)
 
        wg_handshake_response* getHandshakeResponseHeader() const
        {
            return reinterpret_cast<wg_handshake_response*>(getBasicHeader());
        }
 
    public:
        WireGuardHandshakeResponseLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : WireGuardLayer(data, dataLen, prevLayer, packet)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(wg_handshake_response);
        }
 
        WireGuardHandshakeResponseLayer(uint32_t senderIndex, uint32_t receiverIndex,
                                        const uint8_t responderEphemeral[32], const uint8_t encryptedEmpty[16],
                                        const uint8_t mac1[16], const uint8_t mac2[16]);
 
        uint32_t getSenderIndex() const;
 
        uint32_t getReceiverIndex() const;
 
        std::array<uint8_t, 32> getResponderEphemeral() const;
 
        std::array<uint8_t, 16> getEncryptedEmpty() const;
 
        std::array<uint8_t, 16> getMac1() const;
 
        std::array<uint8_t, 16> getMac2() const;
 
        void setSenderIndex(uint32_t senderIndex);
 
        void setReceiverIndex(uint32_t receiverIndex);
 
        void setResponderEphemeral(const std::array<uint8_t, 32>& responderEphemeral);
 
        void setEncryptedEmpty(const std::array<uint8_t, 16>& encryptedEmpty);
 
        void setMac1(const std::array<uint8_t, 16>& mac1);
 
        void setMac2(const std::array<uint8_t, 16>& mac2);
 
        // implement abstract methods
 
        WireGuardMessageType getWireGuardMessageType() const override
        {
            return WireGuardMessageType::HandshakeResponse;
        }
 
        struct SerializedFields : WireGuardLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = WireGuardLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ SenderIndex,    ReceiverIndex, ResponderEphemeral,
                                                              EncryptedEmpty, Mac1,          Mac2 };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor SenderIndex;
 
            static const FieldDescriptor ReceiverIndex;
 
            static const FieldDescriptor ResponderEphemeral;
 
            static const FieldDescriptor EncryptedEmpty;
 
            static const FieldDescriptor Mac1;
 
            static const FieldDescriptor Mac2;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class WireGuardCookieReplyLayer : public WireGuardLayer
    {
    private:
#pragma pack(push, 1)
        typedef struct wg_cookie_reply : wg_common_header
        {
            uint32_t receiverIndex;
            uint8_t nonce[24];
            uint8_t encryptedCookie[32];
        } wg_cookie_reply;
#pragma pack(pop)
 
        wg_cookie_reply* getCookieReplyHeader() const
        {
            return reinterpret_cast<wg_cookie_reply*>(getBasicHeader());
        }
 
    public:
        WireGuardCookieReplyLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : WireGuardLayer(data, dataLen, prevLayer, packet)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(wg_cookie_reply);
        }
 
        WireGuardCookieReplyLayer(uint32_t receiverIndex, const uint8_t nonce[24], const uint8_t encryptedCookie[32]);
 
        uint32_t getReceiverIndex() const;
 
        std::array<uint8_t, 24> getNonce() const;
 
        std::array<uint8_t, 32> getEncryptedCookie() const;
 
        void setReceiverIndex(uint32_t receiverIndex);
 
        void setNonce(const std::array<uint8_t, 24>& nonce);
 
        void setEncryptedCookie(const std::array<uint8_t, 32>& encryptedCookie);
 
        // implement abstract methods
 
        WireGuardMessageType getWireGuardMessageType() const override
        {
            return WireGuardMessageType::CookieReply;
        }
 
        struct SerializedFields : WireGuardLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = WireGuardLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ ReceiverIndex, Nonce, EncryptedCookie };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor ReceiverIndex;
 
            static const FieldDescriptor Nonce;
 
            static const FieldDescriptor EncryptedCookie;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class WireGuardTransportDataLayer : public WireGuardLayer
    {
    private:
#pragma pack(push, 1)
        typedef struct wg_transport_data : wg_common_header
        {
            uint32_t receiverIndex;
            uint64_t counter;
            uint8_t encryptedData[0];
        } wg_transport_data;
#pragma pack(pop)
 
        wg_transport_data* getTransportHeader() const
        {
            return reinterpret_cast<wg_transport_data*>(getBasicHeader());
        }
 
    public:
        WireGuardTransportDataLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : WireGuardLayer(data, dataLen, prevLayer, packet)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(wg_transport_data);
        }
 
        WireGuardTransportDataLayer(uint32_t receiverIndex, uint64_t counter, const uint8_t* encryptedData,
                                    size_t encryptedDataLen);
 
        uint32_t getReceiverIndex() const;
 
        uint64_t getCounter() const;
 
        const uint8_t* getEncryptedData() const;
 
        void setReceiverIndex(uint32_t receiverIndex);
 
        void setCounter(uint64_t counter);
 
        void setEncryptedData(const uint8_t* encryptedData, size_t encryptedDataLen);
 
        // implement abstract methods
 
        WireGuardMessageType getWireGuardMessageType() const override
        {
            return WireGuardMessageType::TransportData;
        }
 
        struct SerializedFields : WireGuardLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = WireGuardLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ ReceiverIndex, Counter };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor ReceiverIndex;
 
            static const FieldDescriptor Counter;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
}  // namespace pcpp