SSLHandshake.h

Go to the documentation of this file.

#ifndef PACKETPP_SSL_HANDSHAKE_MESSAGE
#define PACKETPP_SSL_HANDSHAKE_MESSAGE

#include <utility>
#include "SSLCommon.h"
#include "PointerVector.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:
    SSLExtension(uint8_t* data);

    virtual ~SSLExtension() { }

    SSLExtensionType getType() const;

    uint16_t getTypeAsInt() const;

    uint16_t getLength() const;

    uint16_t getTotalLength() const;

    uint8_t* getData() const;

protected:

    struct SSLExtensionStruct
    {
        uint16_t extensionType;
        uint16_t extensionDataLength;
        uint8_t  extensionData[];
    };

    uint8_t* m_RawData;

    SSLExtensionStruct* getExtensionStruct() const { return (SSLExtensionStruct*)m_RawData; }
};


class SSLServerNameIndicationExtension : public SSLExtension
{
public:
    SSLServerNameIndicationExtension(uint8_t* data) : SSLExtension(data) {}

    std::string getHostName() const;
};


class SSLSupportedVersionsExtension : public SSLExtension
{
public:
    SSLSupportedVersionsExtension(uint8_t* data) : SSLExtension(data) {}

    std::vector<SSLVersion> getSupportedVersions() const;
};


class TLSSupportedGroupsExtension : public SSLExtension
{
    public:
    TLSSupportedGroupsExtension(uint8_t* data) : SSLExtension(data) {}

    std::vector<uint16_t> getSupportedGroups() const;
};


class TLSECPointFormatExtension : public SSLExtension
{
    public:
    TLSECPointFormatExtension(uint8_t* data) : SSLExtension(data) {}

    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; }

    bool allDataExists() const { return m_AllDataExists; }

private:
    uint8_t* m_Data;
    size_t m_DataLen;
    bool m_AllDataExists;
};


class SSLHandshakeLayer;


class SSLHandshakeMessage
{
public:

    virtual ~SSLHandshakeMessage() {}

    static SSLHandshakeMessage* createHandhakeMessage(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);

    virtual ~SSLClientHelloMessage() {}

    ssl_tls_client_server_hello* getClientHelloHeader() const { return (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 getExtensionsLenth() 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;

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);

    virtual ~SSLServerHelloMessage() {}

    ssl_tls_client_server_hello* getServerHelloHeader() const { return (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 getExtensionsLenth() 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;

private:
    PointerVector<SSLExtension> m_ExtensionList;
};


class SSLCertificateMessage : public SSLHandshakeMessage
{
public:

    SSLCertificateMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);

    virtual ~SSLCertificateMessage() {}

    int getNumOfCertificates() const;

    SSLx509Certificate* getCertificate(int index) const;

    // implement abstract methods

    std::string toString() const;

private:
    PointerVector<SSLx509Certificate> m_CertificateList;
};


class SSLHelloRequestMessage : public SSLHandshakeMessage
{
public:

    SSLHelloRequestMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    virtual ~SSLHelloRequestMessage() {}

    // implement abstract methods

    std::string toString() const;
};


class SSLServerKeyExchangeMessage : public SSLHandshakeMessage
{
public:

    SSLServerKeyExchangeMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    ~SSLServerKeyExchangeMessage() {}

    uint8_t* getServerKeyExchangeParams() const;

    size_t getServerKeyExchangeParamsLength() const;

    // implement abstract methods

    std::string toString() const;
};


class SSLClientKeyExchangeMessage : public SSLHandshakeMessage
{
public:

    SSLClientKeyExchangeMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    ~SSLClientKeyExchangeMessage() {}

    uint8_t* getClientKeyExchangeParams() const;

    size_t getClientKeyExchangeParamsLength() const;

    // implement abstract methods

    std::string toString() const;
};


class SSLCertificateRequestMessage : public SSLHandshakeMessage
{
public:

    SSLCertificateRequestMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container);

    ~SSLCertificateRequestMessage() {}

    std::vector<SSLClientCertificateType>& getCertificateTypes();

    uint8_t* getCertificateAuthorityData() const;

    size_t getCertificateAuthorityLength() const;

    // implement abstract methods

    std::string toString() const;

private:
    std::vector<SSLClientCertificateType> m_ClientCertificateTypes;
};


class SSLServerHelloDoneMessage : public SSLHandshakeMessage
{
public:

    SSLServerHelloDoneMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    virtual ~SSLServerHelloDoneMessage() {}

    // implement abstract methods

    std::string toString() const;
};


class SSLCertificateVerifyMessage : public SSLHandshakeMessage
{
public:

    SSLCertificateVerifyMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    virtual ~SSLCertificateVerifyMessage() {}

    uint8_t* getSignedHash() const;

    size_t getSignedHashLength() const;

    // implement abstract methods

    std::string toString() const;
};


class SSLFinishedMessage : public SSLHandshakeMessage
{
public:

    SSLFinishedMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    virtual ~SSLFinishedMessage() {}

    uint8_t* getSignedHash() const;

    size_t getSignedHashLength() const;

    // implement abstract methods

    std::string toString() const;
};


class SSLNewSessionTicketMessage : public SSLHandshakeMessage
{
public:

    SSLNewSessionTicketMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    virtual ~SSLNewSessionTicketMessage() {}

    uint8_t* getSessionTicketData() const;

    size_t getSessionTicketDataLength() const;

    // implement abstract methods

    std::string toString() const;
};


class SSLUnknownMessage : public SSLHandshakeMessage
{
public:

    SSLUnknownMessage(uint8_t* data, size_t dataLen, SSLHandshakeLayer* container) : SSLHandshakeMessage(data, dataLen, container) {}

    virtual ~SSLUnknownMessage() {}

    // implement virtual and abstract methods

    SSLHandshakeType getHandshakeType() const;

    size_t getMessageLength() const;

    std::string toString() const;
};

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) != NULL)
             return (TExtension*)curElem;
    }

    return NULL;
}

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) != NULL)
             return (TExtension*)curElem;
    }

    return NULL;
}

} // namespace pcpp

#endif /* PACKETPP_SSL_HANDSHAKE_MESSAGE */