QuicLayer.h

Go to the documentation of this file.

#pragma once
#include "Layer.h"
#include "Packet.h"
#include <vector>
#include <string>
 
 
namespace pcpp
{
    class QuicV1Layer : public Layer
    {
    public:
        enum class QuicPacketType : uint8_t
        {
            Initial = 0,
            ZeroRTT = 1,
            Handshake = 2,
            Retry = 3,
            VersionNegotiation = 253,
            OneRtt = 254,
        };
 
        enum class QuicHeaderForm : uint8_t
        {
            ShortHeader = 0,
            LongHeader = 1
        };
 
        struct ProtectedPayload
        {
            const uint8_t* data;
            size_t length;
        };
 
        static QuicV1Layer* parseQuicLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        virtual QuicPacketType getPacketType() const = 0;
 
        QuicHeaderForm getHeaderForm() const;
 
        uint8_t getFixedBit() const;
 
        static bool isQuicPort(uint16_t port)
        {
            return port == 443;
        }
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelTransportLayer;
        }
 
    protected:
        QuicV1Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, QUICv1)
        {}
 
        struct quic_common_header
        {
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t : 6, fixedBit : 1, headerForm : 1;
#else
            uint8_t headerForm : 1, fixedBit : 1, : 6;
#endif
        };
 
#pragma pack(push, 1)
        struct quic_long_header
        {
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t packetNumberLength : 2, reserved : 2, longPacketType : 2, fixedBit : 1, headerForm : 1;
#else
            uint8_t headerForm : 1, fixedBit : 1, longPacketType : 2, reserved : 2, packetNumberLength : 2;
#endif
            uint32_t version;
            uint8_t destinationConnectionIdLength;
        };
#pragma pack(pop)
        static_assert(sizeof(quic_long_header) == 6, "quic_long_header size is not 6 bytes");
 
#pragma pack(push, 1)
        struct quic_short_header
        {
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t packetNumberLength : 2, keyPhase : 1, reserved : 2, spinBit : 1, fixedBit : 1, headerForm : 1;
#else
            uint8_t headerForm : 1, fixedBit : 1, spinBit : 1, reserved : 2, keyPhase : 1, packetNumberLength : 2;
#endif
        };
#pragma pack(pop)
        static_assert(sizeof(quic_short_header) == 1, "quic_short_header size is not 1 byte");
 
    private:
        quic_common_header* getCommonHeader() const
        {
            return reinterpret_cast<quic_common_header*>(m_Data);
        }
    };
 
    class QuicV1LongHeaderLayer : public QuicV1Layer
    {
    public:
        QuicPacketType getPacketType() const override;
 
        uint32_t getVersion() const;
 
        std::vector<uint8_t> getDestinationConnectionId() const;
 
        std::string getDestinationConnectionIdAsString() const;
 
        std::vector<uint8_t> getSourceConnectionId() const;
 
        std::string getSourceConnectionIdAsString() const;
 
    protected:
        using QuicV1Layer::QuicV1Layer;
 
        struct OffsetAndLength
        {
            size_t length;
            size_t offset;
 
            OffsetAndLength(size_t length, size_t offset) : length(length), offset(offset)
            {}
        };
 
        OffsetAndLength getDestConIdOffsetAndLength() const;
 
        OffsetAndLength getSrcConIdOffsetAndLength() const;
 
    private:
        static constexpr int destinationConnectionIdOffset = sizeof(quic_long_header);
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        quic_long_header* getLongHeader() const
        {
            return reinterpret_cast<quic_long_header*>(m_Data);
        }
 
        friend class QuicV1Layer;
    };
 
    class QuicV1EstablishmentLayer : public QuicV1LongHeaderLayer
    {
    public:
        uint64_t getLength() const;
 
        // implement abstract methods
 
        size_t getHeaderLen() const override;
 
        ProtectedPayload getProtectedPayload() const;
 
    protected:
        struct VarintValueAndSize
        {
            uint64_t value;
            size_t size;
 
            VarintValueAndSize(uint64_t value, size_t size) : value(value), size(size)
            {}
        };
 
        virtual size_t getLengthOffset() const;
 
        VarintValueAndSize getVarintValueAndSize(size_t offset) const;
 
    private:
        using QuicV1LongHeaderLayer::QuicV1LongHeaderLayer;
    };
 
    class QuicV1InitialLayer : public QuicV1EstablishmentLayer
    {
    public:
        std::vector<uint8_t> getToken() const;
 
        std::string getTokenAsString() const;
 
    private:
        using QuicV1EstablishmentLayer::QuicV1EstablishmentLayer;
 
        size_t getLengthOffset() const override;
 
        size_t getTokenLengthOffset() const;
 
        friend class QuicV1Layer;
    };
 
    class QuicV1ZeroRttLayer : public QuicV1EstablishmentLayer
    {
        using QuicV1EstablishmentLayer::QuicV1EstablishmentLayer;
 
        friend class QuicV1Layer;
    };
 
    class QuicV1HandshakeLayer : public QuicV1EstablishmentLayer
    {
        using QuicV1EstablishmentLayer::QuicV1EstablishmentLayer;
 
        friend class QuicV1Layer;
    };
 
    class QuicV1RetryLayer : public QuicV1LongHeaderLayer
    {
    public:
        std::vector<uint8_t> getRetryToken() const;
 
        std::string getRetryTokenAsString() const;
 
        std::vector<uint8_t> getRetryIntegrityTag() const;
 
        std::string getRetryIntegrityTagAsString() const;
 
        // implement abstract methods
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
    private:
        using QuicV1LongHeaderLayer::QuicV1LongHeaderLayer;
 
        static constexpr size_t retryIntegritySize = 16;
 
        size_t getRetryTokenOffset() const;
 
        friend class QuicV1Layer;
    };
 
    class QuicV1VersionNegotiationLayer : public QuicV1LongHeaderLayer
    {
    public:
        QuicPacketType getPacketType() const override
        {
            return QuicPacketType::VersionNegotiation;
        }
 
        std::vector<uint32_t> getSupportedVersions() const;
 
        // implement abstract methods
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
    private:
        using QuicV1LongHeaderLayer::QuicV1LongHeaderLayer;
 
        friend class QuicV1Layer;
    };
 
    class QuicV1OneRttLayer : public QuicV1Layer
    {
    public:
        QuicPacketType getPacketType() const override
        {
            return QuicPacketType::OneRtt;
        }
 
        bool getSpinBit() const
        {
            return getShortHeader()->spinBit;
        }
 
        bool getKeyPhaseBit() const
        {
            return getShortHeader()->keyPhase;
        }
 
        ProtectedPayload getProtectedPayload() const;
 
        // implement abstract methods
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
    private:
        using QuicV1Layer::QuicV1Layer;
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        quic_short_header* getShortHeader() const
        {
            return reinterpret_cast<quic_short_header*>(m_Data);
        }
 
        friend class QuicV1Layer;
    };
}  // namespace pcpp