SSLLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_SSL_LAYER
#define PACKETPP_SSL_LAYER

#include <map>
#include <vector>
#include "PointerVector.h"
#include "Layer.h"
#include "SSLCommon.h"
#include "SSLHandshake.h"

namespace pcpp
{

    class SSLLayer : public Layer
    {
    public:

        static bool IsSSLMessage(uint16_t srcPort, uint16_t dstPort, uint8_t* data, size_t dataLen);

        static SSLLayer* createSSLMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);

        static std::string sslVersionToString(SSLVersion ver);

        static const std::map<uint16_t, bool>* getSSLPortMap();

        inline ssl_tls_record_layer* getRecordLayer() { return (ssl_tls_record_layer*)m_Data; }

        SSLVersion getRecordVersion();

        SSLRecordType getRecordType();

        // implement abstract methods

        size_t getHeaderLen();

        void parseNextLayer();

        OsiModelLayer getOsiModelLayer() { return OsiModelPresentationLayer; }

    protected:
        SSLLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : Layer(data, dataLen, prevLayer, packet) { m_Protocol = SSL; }

    };


    class SSLHandshakeLayer: public SSLLayer
    {
    public:

        SSLHandshakeLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);

        size_t getHandshakeMessagesCount();

        SSLHandshakeMessage* getHandshakeMessageAt(int index);

        template<class THandshakeMessage>
        THandshakeMessage* getHandshakeMessageOfType();

        template<class THandshakeMessage>
        THandshakeMessage* getNextHandshakeMessageOfType(SSLHandshakeMessage* after);

        // implement abstract methods

        std::string toString();

        void computeCalculateFields() {}

    private:
        PointerVector<SSLHandshakeMessage> m_MessageList;
    };


    class SSLChangeCipherSpecLayer : public SSLLayer
    {
    public:

        SSLChangeCipherSpecLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : SSLLayer(data, dataLen, prevLayer, packet) {}

        ~SSLChangeCipherSpecLayer() {}

        // implement abstract methods

        std::string toString();

        void computeCalculateFields() {}
    };


    class SSLAlertLayer : public SSLLayer
    {
    public:

        SSLAlertLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : SSLLayer(data, dataLen, prevLayer, packet) {}

        ~SSLAlertLayer() {}

        SSLAlertLevel getAlertLevel();

        SSLAlertDescription getAlertDescription();

        // implement abstract methods

        std::string toString();

        void computeCalculateFields() {}
    };


    class SSLApplicationDataLayer : public SSLLayer
    {
    public:

        SSLApplicationDataLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : SSLLayer(data, dataLen, prevLayer, packet) {}

        ~SSLApplicationDataLayer() {}

        uint8_t* getEncrpytedData();

        size_t getEncrpytedDataLen();

        // implement abstract methods

        std::string toString();

        void computeCalculateFields() {}
    };

    template<class THandshakeMessage>
    THandshakeMessage* SSLHandshakeLayer::getHandshakeMessageOfType()
    {
        size_t vecSize = m_MessageList.size();
        for (size_t i = 0; i < vecSize; i++)
        {
            SSLHandshakeMessage* curElem = m_MessageList.at(i);
             if (dynamic_cast<THandshakeMessage*>(curElem) != NULL)
                 return (THandshakeMessage*)curElem;
        }

        // element not found
        return NULL;
    }

    template<class THandshakeMessage>
    THandshakeMessage* SSLHandshakeLayer::getNextHandshakeMessageOfType(SSLHandshakeMessage* after)
    {
        size_t vecSize = m_MessageList.size();
        size_t afterIndex;

        // find the index of "after"
        for (afterIndex = 0; afterIndex < vecSize; afterIndex++)
        {
            SSLHandshakeMessage* curElem = m_MessageList.at(afterIndex);
            if (curElem == after)
                break;
        }

        // "after" not found
        if (afterIndex == vecSize)
            return NULL;

        for (size_t i = afterIndex+1; i < vecSize; i++)
        {
            SSLHandshakeMessage* curElem = m_MessageList.at(i);
             if (dynamic_cast<THandshakeMessage*>(curElem) != NULL)
                 return (THandshakeMessage*)curElem;
        }

        // element not found
        return NULL;
    }

} // namespace pcpp

#endif /* PACKETPP_SSL_LAYER */