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) {}
 
    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 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:
 
    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;
 
    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;
 
    // implement abstract methods
 
    std::string toString() const;
 
private:
    PointerVector<SSLExtension> m_ExtensionList;
 
};
 
 
class SSLServerHelloMessage : public SSLHandshakeMessage
{
public:
 
    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;
 
    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;
 
    // 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 */