IPSecLayer.h

Go to the documentation of this file.

#pragma once
 
 
#include "Layer.h"
 
namespace pcpp
{
#pragma pack(push, 1)
    struct ipsec_authentication_header
    {
        uint8_t nextHeader;
        uint8_t payloadLen;
        uint16_t reserved;
        uint32_t spi;
        uint32_t sequenceNumber;
    };
#pragma pack(pop)
    static_assert(sizeof(ipsec_authentication_header) == 12, "ipsec_authentication_header size is not 12 bytes");
 
#pragma pack(push, 1)
    struct ipsec_esp
    {
        uint32_t spi;
        uint32_t sequenceNumber;
    };
#pragma pack(pop)
    static_assert(sizeof(ipsec_esp) == 8, "ipsec_esp size is not 8 bytes");
 
    class AuthenticationHeaderLayer : public Layer
    {
    public:
        AuthenticationHeaderLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, AuthenticationHeader)
        {}
 
        ipsec_authentication_header* getAHHeader() const
        {
            return reinterpret_cast<ipsec_authentication_header*>(m_Data);
        }
 
        uint32_t getSPI() const;
 
        uint32_t getSequenceNumber() const;
 
        size_t getICVLength() const;
 
        uint8_t* getICVBytes() const;
 
        std::string getICVHexStream() const;
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        size_t getHeaderLen() const override
        {
            return static_cast<size_t>(4) * (getAHHeader()->payloadLen + 2);
        }
 
        void parseNextLayer() override;
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ SPI, SequenceNumber, ICV };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor SPI;
 
            static const FieldDescriptor SequenceNumber;
 
            static const FieldDescriptor ICV;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        // this layer supports parsing only
        AuthenticationHeaderLayer()
        {}
    };
 
    class ESPLayer : public Layer
    {
    public:
        ESPLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, ESP)
        {}
 
        ipsec_esp* getESPHeader() const
        {
            return reinterpret_cast<ipsec_esp*>(m_Data);
        }
 
        uint32_t getSPI() const;
 
        uint32_t getSequenceNumber() const;
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(ipsec_esp);
        }
 
        void parseNextLayer() override;
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelTransportLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ SPI, SequenceNumber };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor SPI;
 
            static const FieldDescriptor SequenceNumber;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        // this layer supports parsing only
        ESPLayer()
        {}
    };
 
    // implementation of inline methods
 
    bool AuthenticationHeaderLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        if (dataLen < sizeof(ipsec_authentication_header))
            return false;
 
        size_t payloadLen = 4 * (data[1] + 2);
        if (payloadLen < sizeof(ipsec_authentication_header) || payloadLen > dataLen)
            return false;
 
        return true;
    }
 
    bool ESPLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        return data && dataLen >= sizeof(ipsec_esp);
    }
}  // namespace pcpp