SSLHandshake.h

Go to the documentation of this file.

#ifndef PACKETPP_SSL_HANDSHAKE_MESSAGE
#define PACKETPP_SSL_HANDSHAKE_MESSAGE

#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) {}

    inline uint16_t getID() { return m_Id; }

    inline std::string asString() { return m_Name; }

    inline SSLKeyExchangeAlgorithm getKeyExchangeAlg() { return m_KeyExAlg; }

    inline SSLAuthenticationAlgorithm getAuthAlg() { return m_AuthAlg; }

    inline SSLSymetricEncryptionAlgorithm getSymKeyAlg() { return m_SymKeyAlg; }

    inline SSLHashingAlgorithm getMACAlg() { 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();

    uint16_t getTypeAsInt();

    uint16_t getLength();

    uint16_t getTotalLength();

    uint8_t* getData();

protected:

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

    uint8_t* m_RawData;

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


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

    std::string getHostName();
};


class SSLx509Certificate
{
public:

    SSLx509Certificate(uint8_t* data, size_t dataLen, bool allDataExists)
        : m_Data(data), m_DataLen(dataLen), m_AllDataExists(allDataExists) {}

    uint8_t* getData() { return m_Data; }

    size_t getDataLength() { return m_DataLen; }

    bool allDataExists() { 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();

    virtual size_t getMessageLength();

    virtual bool isMessageComplete();

    inline SSLHandshakeLayer* getContainingLayer() { return m_Container; }

    virtual std::string toString() = 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:

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

    virtual ~SSLClientHelloMessage() {}

    inline ssl_tls_client_server_hello* getClientHelloHeader() { return (ssl_tls_client_server_hello*)m_Data; }

    SSLVersion getHandshakeVersion();

    uint8_t getSessionIDLength();

    uint8_t* getSessionID();

    int getCipherSuiteCount();

    SSLCipherSuite* getCipherSuite(int index);

    uint8_t getCompressionMethodsValue();

    int getExtensionCount();

    uint16_t getExtensionsLenth();

    SSLExtension* getExtension(int index);

    SSLExtension* getExtensionOfType(uint16_t type);

    SSLExtension* getExtensionOfType(SSLExtensionType type);

    template<class TExtension>
    TExtension* getExtensionOfType();

    // implement abstract methods

    std::string toString();

private:
    PointerVector<SSLExtension> m_ExtensionList;

};


class SSLServerHelloMessage : public SSLHandshakeMessage
{
public:

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

    virtual ~SSLServerHelloMessage() {}

    inline ssl_tls_client_server_hello* getServerHelloHeader() { return (ssl_tls_client_server_hello*)m_Data; }

    SSLVersion getHandshakeVersion();

    uint8_t getSessionIDLength();

    uint8_t* getSessionID();

    SSLCipherSuite* getCipherSuite();

    uint8_t getCompressionMethodsValue();

    int getExtensionCount();

    uint16_t getExtensionsLenth();

    SSLExtension* getExtension(int index);

    SSLExtension* getExtensionOfType(uint16_t type);

    SSLExtension* getExtensionOfType(SSLExtensionType type);

    template<class TExtension>
    TExtension* getExtensionOfType();

    // implement abstract methods

    std::string toString();

private:
    PointerVector<SSLExtension> m_ExtensionList;
};


class SSLCertificateMessage : public SSLHandshakeMessage
{
public:

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

    virtual ~SSLCertificateMessage() {}

    int getNumOfCertificates();

    SSLx509Certificate* getCertificate(int index);

    // implement abstract methods

    std::string toString();

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


class SSLServerKeyExchangeMessage : public SSLHandshakeMessage
{
public:

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

    ~SSLServerKeyExchangeMessage() {}

    uint8_t* getServerKeyExchangeParams();

    size_t getServerKeyExchangeParamsLength();

    // implement abstract methods

    std::string toString();
};


class SSLClientKeyExchangeMessage : public SSLHandshakeMessage
{
public:

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

    ~SSLClientKeyExchangeMessage() {}

    uint8_t* getClientKeyExchangeParams();

    size_t getClientKeyExchangeParamsLength();

    // implement abstract methods

    std::string toString();
};


class SSLCertificateRequestMessage : public SSLHandshakeMessage
{
public:

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

    ~SSLCertificateRequestMessage() {}

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

    uint8_t* getCertificateAuthorityData();

    size_t getCertificateAuthorityLength();

    // implement abstract methods

    std::string toString();

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


class SSLCertificateVerifyMessage : public SSLHandshakeMessage
{
public:

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

    virtual ~SSLCertificateVerifyMessage() {}

    uint8_t* getSignedHash();

    size_t getSignedHashLength();

    // implement abstract methods

    std::string toString();
};


class SSLFinishedMessage : public SSLHandshakeMessage
{
public:

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

    virtual ~SSLFinishedMessage() {}

    uint8_t* getSignedHash();

    size_t getSignedHashLength();

    // implement abstract methods

    std::string toString();
};


class SSLNewSessionTicketMessage : public SSLHandshakeMessage
{
public:

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

    virtual ~SSLNewSessionTicketMessage() {}

    uint8_t* getSessionTicketData();

    size_t getSessionTicketDataLength();

    // implement abstract methods

    std::string toString();
};


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

    size_t getMessageLength();

    std::string toString();
};

template<class TExtension>
TExtension* SSLClientHelloMessage::getExtensionOfType()
{
    size_t vecSize = m_ExtensionList.size();
    for (size_t i = 0; i < vecSize; i++)
    {
        SSLExtension* curElem = m_ExtensionList.at(i);
         if (dynamic_cast<TExtension*>(curElem) != NULL)
             return (TExtension*)curElem;
    }

    return NULL;
}

template<class TExtension>
TExtension* SSLServerHelloMessage::getExtensionOfType()
{
    size_t vecSize = m_ExtensionList.size();
    for (size_t i = 0; i < vecSize; i++)
    {
        SSLExtension* curElem = m_ExtensionList.at(i);
         if (dynamic_cast<TExtension*>(curElem) != NULL)
             return (TExtension*)curElem;
    }

    return NULL;
}

} // namespace pcpp

#endif /* PACKETPP_SSL_HANDSHAKE_MESSAGE */