SSLHandshake.h

Go to the documentation of this file.

#pragma once
 
#include <utility>
#include <type_traits>
#include "SSLCommon.h"
#include "PointerVector.h"
#include "Asn1Codec.h"
#include "X509Decoder.h"
 
 
namespace pcpp
{
    class SSLCipherSuite
    {
    public:
        SSLCipherSuite(uint16_t id, SSLKeyExchangeAlgorithm keyExAlg, SSLAuthenticationAlgorithm authAlg,
                       SSLSymetricEncryptionAlgorithm symKeyAlg, SSLHashingAlgorithm MACAlg, const char* name)
            : m_Id(id), m_KeyExAlg(keyExAlg), m_AuthAlg(authAlg), m_SymKeyAlg(symKeyAlg), m_MACAlg(MACAlg), m_Name(name)
        {}
 
        uint16_t getID() const
        {
            return m_Id;
        }
 
        std::string asString() const
        {
            return m_Name;
        }
 
        SSLKeyExchangeAlgorithm getKeyExchangeAlg() const
        {
            return m_KeyExAlg;
        }
 
        SSLAuthenticationAlgorithm getAuthAlg() const
        {
            return m_AuthAlg;
        }
 
        SSLSymetricEncryptionAlgorithm getSymKeyAlg() const
        {
            return m_SymKeyAlg;
        }
 
        SSLHashingAlgorithm getMACAlg() const
        {
            return m_MACAlg;
        }
 
        static SSLCipherSuite* getCipherSuiteByID(uint16_t id);
 
        static SSLCipherSuite* getCipherSuiteByName(std::string name);
 
    private:
        uint16_t m_Id;
        SSLKeyExchangeAlgorithm m_KeyExAlg;
        SSLAuthenticationAlgorithm m_AuthAlg;
        SSLSymetricEncryptionAlgorithm m_SymKeyAlg;
        SSLHashingAlgorithm m_MACAlg;
        std::string m_Name;
    };
 
    class SSLExtension
    {
    public:
        PCPP_DEPRECATED("Unbound memory span. Use the constructor with bounded span.")
        explicit SSLExtension(uint8_t* data);
 
        SSLExtension(uint8_t* data, size_t dataLen);
 
        virtual ~SSLExtension() = default;
 
        SSLExtensionType getType() const;
 
        uint16_t getTypeAsInt() const;
 
        uint16_t getLength() const;
 
        uint16_t getTotalLength() const;
 
        uint8_t* getData() const;
 
        template <typename T, typename std::enable_if_t<std::is_base_of<SSLExtension, T>::value, bool> = true>
        static std::unique_ptr<T> tryCreateExtension(uint8_t* data, size_t dataLen)
        {
            if (data == nullptr || dataLen < sizeof(SSLExtensionStruct))
            {
                return nullptr;
            }
 
            auto* extStruct = reinterpret_cast<SSLExtensionStruct*>(data);
            if (dataLen < sizeof(SSLExtensionStruct) + extStruct->getDataLength())
            {
                return nullptr;
            }
 
            return std::make_unique<T>(data, dataLen);
        }
 
    protected:
        struct SSLExtensionStruct
        {
            uint16_t extensionType;
            uint16_t extensionDataLength;
            uint8_t extensionData[];
 
            uint16_t getDataLength() const;
        };
 
        uint8_t* m_RawData;
        size_t m_RawDataLen;
 
        SSLExtensionStruct* getExtensionStruct() const
        {
            return reinterpret_cast<SSLExtensionStruct*>(m_RawData);
        }
    };
 
    class SSLServerNameIndicationExtension : public SSLExtension
    {
    public:
        using SSLExtension::SSLExtension;
 
        std::string getHostName() const;
    };
 
    class SSLSupportedVersionsExtension : public SSLExtension
    {
    public:
        using SSLExtension::SSLExtension;
 
        std::vector<SSLVersion> getSupportedVersions() const;
    };
 
    class TLSSupportedGroupsExtension : public SSLExtension
    {
    public:
        using SSLExtension::SSLExtension;
 
        std::vector<uint16_t> getSupportedGroups() const;
    };
 
    class TLSECPointFormatExtension : public SSLExtension
    {
    public:
        using SSLExtension::SSLExtension;
 
        std::vector<uint8_t> getECPointFormatList() const;
    };
 
    class SSLx509Certificate
    {
    public:
        SSLx509Certificate(uint8_t* data, size_t dataLen, bool allDataExists)
            : m_Data(data), m_DataLen(dataLen), m_AllDataExists(allDataExists)
        {}
 
        uint8_t* getData() const
        {
            return m_Data;
        }
 
        size_t getDataLength() const
        {
            return m_DataLen;
        }
 
        Asn1SequenceRecord* getRootAsn1Record();
 
        std::unique_ptr<X509Certificate> getX509Certificate();
 
        bool allDataExists() const
        {
            return m_AllDataExists;
        }
 
    private:
        std::unique_ptr<Asn1Record> m_Asn1Record;
        uint8_t* m_Data;
        size_t m_DataLen;
        bool m_AllDataExists;
    };
 
    class SSLHandshakeLayer;
 
    class SSLHandshakeMessage
    {
    public:
        virtual ~SSLHandshakeMessage() = default;
 
        static SSLHandshakeMessage* createHandshakeMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);
 
        virtual SSLHandshakeType getHandshakeType() const;
 
        virtual size_t getMessageLength() const;
 
        virtual bool isMessageComplete() const;
 
        SSLHandshakeLayer* getContainingLayer() const
        {
            return m_Container;
        }
 
        virtual std::string toString() const = 0;
 
    protected:
        SSLHandshakeMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);
 
        uint8_t* m_Data;
        size_t m_DataLen;
        SSLHandshakeLayer* m_Container;
    };
 
    class SSLClientHelloMessage : public SSLHandshakeMessage
    {
    public:
        struct ClientHelloTLSFingerprint
        {
            uint16_t tlsVersion;
            std::vector<uint16_t> cipherSuites;
            std::vector<uint16_t> extensions;
            std::vector<uint16_t> supportedGroups;
            std::vector<uint8_t> ecPointFormats;
 
            std::string toString();
 
            std::string toMD5();
 
            std::pair<std::string, std::string> toStringAndMD5();
        };
 
        SSLClientHelloMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);
 
        ~SSLClientHelloMessage() override = default;
 
        ssl_tls_client_server_hello* getClientHelloHeader() const
        {
            return reinterpret_cast<ssl_tls_client_server_hello*>(m_Data);
        }
 
        SSLVersion getHandshakeVersion() const;
 
        uint8_t getSessionIDLength() const;
 
        uint8_t* getSessionID() const;
 
        int getCipherSuiteCount() const;
 
        SSLCipherSuite* getCipherSuite(int index) const;
 
        uint16_t getCipherSuiteID(int index, bool& isValid) const;
 
        uint8_t getCompressionMethodsValue() const;
 
        int getExtensionCount() const;
 
        uint16_t getExtensionsLength() const;
 
        SSLExtension* getExtension(int index) const;
 
        SSLExtension* getExtensionOfType(uint16_t type) const;
 
        SSLExtension* getExtensionOfType(SSLExtensionType type) const;
 
        template <class TExtension> TExtension* getExtensionOfType() const;
 
        ClientHelloTLSFingerprint generateTLSFingerprint() const;
 
        // implement abstract methods
 
        std::string toString() const override;
 
    private:
        PointerVector<SSLExtension> m_ExtensionList;
    };
 
    class SSLServerHelloMessage : public SSLHandshakeMessage
    {
    public:
        struct ServerHelloTLSFingerprint
        {
            uint16_t tlsVersion;
            uint16_t cipherSuite;
            std::vector<uint16_t> extensions;
 
            std::string toString();
 
            std::string toMD5();
 
            std::pair<std::string, std::string> toStringAndMD5();
        };
 
        SSLServerHelloMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);
 
        ~SSLServerHelloMessage() override = default;
 
        ssl_tls_client_server_hello* getServerHelloHeader() const
        {
            return reinterpret_cast<ssl_tls_client_server_hello*>(m_Data);
        }
 
        SSLVersion getHandshakeVersion() const;
 
        uint8_t getSessionIDLength() const;
 
        uint8_t* getSessionID() const;
 
        SSLCipherSuite* getCipherSuite() const;
 
        uint16_t getCipherSuiteID(bool& isValid) const;
 
        uint8_t getCompressionMethodsValue() const;
 
        int getExtensionCount() const;
 
        uint16_t getExtensionsLength() const;
 
        SSLExtension* getExtension(int index) const;
 
        SSLExtension* getExtensionOfType(uint16_t type) const;
 
        SSLExtension* getExtensionOfType(SSLExtensionType type) const;
 
        template <class TExtension> TExtension* getExtensionOfType() const;
 
        ServerHelloTLSFingerprint generateTLSFingerprint() const;
 
        // implement abstract methods
 
        std::string toString() const override;
 
    private:
        PointerVector<SSLExtension> m_ExtensionList;
    };
 
    class SSLCertificateMessage : public SSLHandshakeMessage
    {
    public:
        SSLCertificateMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);
 
        ~SSLCertificateMessage() override = default;
 
        int getNumOfCertificates() const;
 
        SSLx509Certificate* getCertificate(int index) const;
 
        // implement abstract methods
 
        std::string toString() const override;
 
    private:
        PointerVector<SSLx509Certificate> m_CertificateList;
    };
 
    class SSLHelloRequestMessage : public SSLHandshakeMessage
    {
    public:
        SSLHelloRequestMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLHelloRequestMessage() override = default;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLServerKeyExchangeMessage : public SSLHandshakeMessage
    {
    public:
        SSLServerKeyExchangeMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLServerKeyExchangeMessage() override = default;
 
        uint8_t* getServerKeyExchangeParams() const;
 
        size_t getServerKeyExchangeParamsLength() const;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLClientKeyExchangeMessage : public SSLHandshakeMessage
    {
    public:
        SSLClientKeyExchangeMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLClientKeyExchangeMessage() override = default;
 
        uint8_t* getClientKeyExchangeParams() const;
 
        size_t getClientKeyExchangeParamsLength() const;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLCertificateRequestMessage : public SSLHandshakeMessage
    {
    public:
        SSLCertificateRequestMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);
 
        ~SSLCertificateRequestMessage() override = default;
 
        std::vector<SSLClientCertificateType>& getCertificateTypes();
 
        uint8_t* getCertificateAuthorityData() const;
 
        size_t getCertificateAuthorityLength() const;
 
        // implement abstract methods
 
        std::string toString() const override;
 
    private:
        std::vector<SSLClientCertificateType> m_ClientCertificateTypes;
    };
 
    class SSLServerHelloDoneMessage : public SSLHandshakeMessage
    {
    public:
        SSLServerHelloDoneMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLServerHelloDoneMessage() override = default;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLCertificateVerifyMessage : public SSLHandshakeMessage
    {
    public:
        SSLCertificateVerifyMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLCertificateVerifyMessage() override = default;
 
        uint8_t* getSignedHash() const;
 
        size_t getSignedHashLength() const;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLFinishedMessage : public SSLHandshakeMessage
    {
    public:
        SSLFinishedMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLFinishedMessage() override = default;
 
        uint8_t* getSignedHash() const;
 
        size_t getSignedHashLength() const;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLNewSessionTicketMessage : public SSLHandshakeMessage
    {
    public:
        SSLNewSessionTicketMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLNewSessionTicketMessage() override = default;
 
        uint8_t* getSessionTicketData() const;
 
        size_t getSessionTicketDataLength() const;
 
        // implement abstract methods
 
        std::string toString() const override;
    };
 
    class SSLUnknownMessage : public SSLHandshakeMessage
    {
    public:
        SSLUnknownMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container)
            : SSLHandshakeMessage(data, dataLen, container)
        {}
 
        ~SSLUnknownMessage() override = default;
 
        // implement virtual and abstract methods
 
        SSLHandshakeType getHandshakeType() const override;
 
        size_t getMessageLength() const override;
 
        std::string toString() const override;
    };
 
    template <class TExtension> TExtension* SSLClientHelloMessage::getExtensionOfType() const
    {
        size_t vecSize = m_ExtensionList.size();
        for (size_t i = 0; i < vecSize; i++)
        {
            SSLExtension* curElem = const_cast<SSLExtension*>(m_ExtensionList.at(i));
            if (dynamic_cast<TExtension*>(curElem) != nullptr)
                return static_cast<TExtension*>(curElem);
        }
 
        return nullptr;
    }
 
    template <class TExtension> TExtension* SSLServerHelloMessage::getExtensionOfType() const
    {
        size_t vecSize = m_ExtensionList.size();
        for (size_t i = 0; i < vecSize; i++)
        {
            SSLExtension* curElem = const_cast<SSLExtension*>(m_ExtensionList.at(i));
            if (dynamic_cast<TExtension*>(curElem) != nullptr)
                return static_cast<TExtension*>(curElem);
        }
 
        return nullptr;
    }
}  // namespace pcpp