cSSLMsg.h

Go to the documentation of this file.

//
//
#ifndef _INC_cSSLMsgL_H
#define _INC_cSSLMsg_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "SSLTypes.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSSLMsg);
        class cHashWrap;
 
#pragma pack(1) // byte packed.
 
        class CATTR_PACKED cSSLMsgHeader : public cSSL
        {
 
        public:
                static const size_t k_nSizePref = 3;    
 
                BYTE m_nMsgType;        
                BYTE m_nVersion3;       
                BYTE m_nVersion;        
 
                BYTE m_nContLengthH;    
                BYTE m_nContLengthL;    
 
        public:
                cSSLMsgHeader() noexcept
                {
                        // uninit.
                }
                cSSLMsgHeader(SSL_MSG_TYPE eMsgType, SSL_VERSION_TYPE eVer, WORD wContLen) 
                        : m_nMsgType((BYTE)eMsgType)
                        , m_nVersion3(SSL_VERSION_MAJOR_BYTE)
                        , m_nVersion((BYTE)eVer)
                        , m_nContLengthH(HIBYTE(wContLen))
                        , m_nContLengthL(LOBYTE(wContLen))
                {
                        ASSERT(isValid());
                }
 
                bool isValidMsgType() const noexcept
                {
                        // Only known valid messages.
                        switch (m_nMsgType)
                        {
                        case SSL_MSG_CHANGE_CIPHER_SPEC:
                        case SSL_MSG_ALERT:
                        case SSL_MSG_HANDSHAKE:
                        case SSL_MSG_APPLICATION_DATA:
                                return true;
                        default:
                                return false;
                        }
                }
                SSL_MSG_TYPE get_MsgType() const noexcept
                {
                        return (SSL_MSG_TYPE)m_nMsgType;
                }
                void put_MsgType(SSL_MSG_TYPE eMsgType)
                {
                        m_nMsgType = (BYTE)eMsgType;
                        ASSERT(isValidMsgType());
                }
 
                bool isValidVersion() const noexcept
                {
                        // Only known valid versions.
                        if (m_nVersion3 != SSL_VERSION_MAJOR_BYTE)
                                return false;
                        if (m_nVersion < SSL_VER_SSL_3 || m_nVersion > SSL_VERSION_SUPPORT_MAX)
                                return false;   // not valid version.
                        return true;
                }
                SSL_VERSION_TYPE get_Version() const noexcept
                {
                        return (SSL_VERSION_TYPE)m_nVersion;
                }
                void put_Version(SSL_VERSION_TYPE v)
                {
                        m_nVersion3 = SSL_VERSION_MAJOR_BYTE;
                        m_nVersion = (BYTE)v;
                        ASSERT(isValidVersion());
                }
 
                bool isValidContLength() const noexcept
                {
                        // TLS encrypted messages can have up to 256 bytes of padding
                        WORD nContLength = get_ContLength();
                        if (nContLength < 1 || nContLength > k_Content_Size_Max)        // upper bounds.
                                return false;
                        return true;
                }
                WORD get_ContLength() const noexcept
                {
                        return MAKEWORD(m_nContLengthL, m_nContLengthH);
                }
                void put_ContLength(WORD nContLen)
                {
                        m_nContLengthH = HIBYTE(nContLen);
                        m_nContLengthL = LOBYTE(nContLen);
                        ASSERT(isValidContLength());
                }
 
                bool isValid() const
                {
                        return isValidMsgType() && isValidVersion() && isValidContLength();
                }
 
                void Set(SSL_MSG_TYPE eMsgType, SSL_VERSION_TYPE eVer, WORD wContLength)
                {
                        put_MsgType(eMsgType);
                        put_Version(eVer);
                        put_ContLength(wContLength);
                }
        };
 
        class CATTR_PACKED cSSLMsgHandCert : public cSSL
        {
        };
 
        class CATTR_PACKED cSSLMsgHandExt : public cSSL
        {
 
        public:
                BYTE m_nTypeH;          
                BYTE m_nTypeL;          
                BYTE m_nLengthH;        
                BYTE m_nLengthL;        
 
        public:
                TLS_EXT_TYPE get_ExtType() const noexcept
                {
                        return (TLS_EXT_TYPE)MAKEWORD(m_nTypeL, m_nTypeH);
                }
                void put_ExtType(TLS_EXT_TYPE eType) noexcept
                {
                        m_nTypeH = HIBYTE(eType);
                        m_nTypeL = LOBYTE(eType);
                }
                WORD get_ExtLen() const noexcept
                {
                        return MAKEWORD(m_nLengthL, m_nLengthH);
                }
                void put_ExtLen(size_t wLen) noexcept
                {
                        m_nLengthH = HIBYTE(wLen);
                        m_nLengthL = LOBYTE(wLen);
                }
 
                BYTE* get_ExtData() noexcept
                {
                        return (BYTE*)(this + 1);       // Data block to follow.
                }
                const BYTE* get_ExtData() const noexcept
                {
                        return (const BYTE*)(this + 1); // Data block to follow.
                }
        };
 
        class CATTR_PACKED cSSLMsgHandshake : public cSSL
        {
 
        public:
                BYTE m_nHandType;       
                BYTE m_aLen[3];         
 
                // Followed by Handshake content/payload. cSSLMsgHandHello, cSSLMsgHandExt, etc.
 
        public:
 
                SSL_HAND_TYPE get_HandType() const
                {
                        return (SSL_HAND_TYPE)m_nHandType;
                }
                void put_HandType(SSL_HAND_TYPE eHandType)
                {
                        m_nHandType = (BYTE)eHandType;
                }
 
                DWORD get_Length() const
                {
                        return cMemT::GetNVal3(m_aLen);
                }
                void put_Length(DWORD len)
                {
                        cMemT::SetNVal3(m_aLen, len);
                }
 
                const BYTE* get_DataPtr() const
                {
                        // Data to follow.
                        // cSSLMsgHandHello etc.
                        return (const BYTE*)(this + 1);
                }
                BYTE* get_DataPtr()
                {
                        // Data to follow.
                        return (BYTE*)(this + 1);
                }
        };
 
        class CATTR_PACKED cSSLMsgAlert : public cSSL
        {
        public:
                BYTE m_Level;           
                BYTE m_Description;     
        public:
                SSL_ALERT_LEVEL_TYPE get_Level() const
                {
                        return (SSL_ALERT_LEVEL_TYPE)m_Level;
                }
                SSL_ALERT_TYPE get_Description() const
                {
                        return (SSL_ALERT_TYPE)m_Description;
                }
        };
 
        class CATTR_PACKED cSSLMsgChangeCipherSpec : public cSSL
        {
        public:
                BYTE m_ProtocolType;    
        };
 
        class CATTR_PACKED cSSLMsgX : public cSSL
        {
 
        public:
 
#if defined(USE_ZLIB)
                static const size_t k_SSL_COMPRESSION_ADD = 1024;
#else
                static const size_t k_SSL_COMPRESSION_ADD = 0;
#endif
 
                static const size_t k_SSL_PADDING_ADD = 256;    // (0-256)
 
                static const size_t k_Msg_Size_Max = sizeof(cSSLMsgHeader) + 16 /* IV 8 + 8 */ + k_MAC_Size_Max + k_SSL_PADDING_ADD + k_Content_Size_Max + k_SSL_COMPRESSION_ADD;
 
                cSSLMsgHeader m_Hdr;            
 
                union CATTR_PACKED uContent     
                {
                        cSSLMsgChangeCipherSpec m_ChangeCipherSpec;     
                        cSSLMsgAlert m_Alert;                                           
                        cSSLMsgHandshake m_Handshake;                           
 
                        struct cSSLMsgApplication
                        {
                        } m_Application;
 
                        BYTE m_Iv[8];   // May prefix other data if Ver >= 1
 
                } m_u;
 
                // Only after CipherStateChange has occurred. extra stuff.
                // Message authentication code (MAC)(optional) http://en.wikipedia.org/wiki/Message_authentication_code
                // Padding for block ciphers.
                // etc.
 
        public:
                static HRESULT GRAYCALL CheckSSLClientHello(const void* pData, size_t nSize);
        };
 
        class GRAYLIB_LINK CATTR_PACKED cSSLCtr
        {
 
                typedef cSSLCtr THIS_t;
 
        private:
                BYTE m_Data[8];         
 
        public:
                cSSLCtr()
                {
                        SetZeroCtr();
                }
                cSSLCtr(UINT i)
                {
                        SetZeroCtr();
                        cMemT::SetHtoN(m_Data + sizeof(m_Data) - sizeof(UINT), i);
                }
                void SetZeroCtr()
                {
                        cMem::Zero(m_Data, sizeof(m_Data));
                }
                bool isZero() const
                {
                        return cMem::IsZeros(m_Data, sizeof(m_Data));
                }
                const BYTE* get_Ctr() const
                {
                        return m_Data;
                }
                void SetFillCtr()
                {
                        cMem::Fill(m_Data, sizeof(m_Data) - 1, 0xFF);
                        m_Data[sizeof(m_Data) - 1] = 0x00;
                }
                COMPARE_t Compare(const THIS_t& n) const
                {
                        return ::memcmp(m_Data, n.m_Data, sizeof(THIS_t));
                }
 
                bool IncCtr();
        };
 
#pragma pack()  // end packing.
 
        //**********************************************************
 
        class GRAYLIB_LINK cSSLMsgHandHello : public cSSL
        {
 
        public:
                BYTE m_nClientVersion3;         
                BYTE m_nClientVersion;          
 
                DWORD m_TimeUnixGmt;                    
                BYTE m_Random[28];                              
 
                cHeapBlock m_SessionId;         
                cArrayVal<SSL_CipherSuite_t> m_aCipherSuite;    
                cArrayVal<SSL_Compress_t> m_aCompressionMethod; 
                cHeapBlock m_Extensions;                
 
        public:
                HRESULT ReadHello(const BYTE* pData, size_t nSize);
                size_t get_WriteHelloSize() const noexcept;
                HRESULT WriteHello(BYTE* pData) const;
        };
 
        class GRAYLIB_LINK cSSLMsg : public cHeapBlock, public cSSL
        {
 
                typedef cHeapBlock SUPER_t;
 
        private:
                WORD m_nContLength;                     
 
        public:
                cSSLMsg(size_t nSizeMax = cSSLMsgX::k_Msg_Size_Max) noexcept;
                cSSLMsg(SSL_MSG_TYPE eMsgType, SSL_VERSION_TYPE eVer, WORD wContLen);
                ~cSSLMsg();
 
                const BYTE* get_MsgRaw() const noexcept
                {
                        // may be nullptr?
                        return SUPER_t::get_DataBytes();
                }
                cSSLMsgX& get_Msg() const
                {
                        ASSERT(SUPER_t::isValidPtr());
                        return *((cSSLMsgX*)get_Data());
                }
 
                void ResetMsg()
                {
                        ASSERT(SUPER_t::isValidPtr());
                        m_nContLength = 0;
                        cMem::Zero(get_Data(), sizeof(cSSLMsgHeader));
                }
 
                SSL_MSG_TYPE get_MsgType() const
                {
                        if (m_nContLength == 0)
                                return SSL_MSG_UNK;
                        return get_Msg().m_Hdr.get_MsgType();
                }
                void put_MsgType(SSL_MSG_TYPE eMsgType)
                {
                        get_Msg().m_Hdr.put_MsgType(eMsgType);
                }
 
                SSL_VERSION_TYPE get_Version() const
                {
                        return get_Msg().m_Hdr.get_Version();
                }
                void put_Version(SSL_VERSION_TYPE v)
                {
                        get_Msg().m_Hdr.put_Version(v);
                }
 
                size_t get_ContLength() const noexcept
                {
                        return m_nContLength;
                }
                void put_ContLength(size_t nContLen)
                {
                        this->m_nContLength = (WORD)nContLen;
                        get_Msg().m_Hdr.put_ContLength((WORD)nContLen);
                }
 
                BYTE* get_Cont0() const
                {
                        return get_Msg().m_u.m_Iv;
                }
                BYTE* get_Iv() const
                {
                        return get_Cont0();
                }
 
                bool UpdateReadHdr();
 
                HRESULT ReadRecord(cStreamInput& s);
 
                UNITTEST2_PREDEF(cSSLMsg);
        };
 
        class GRAYLIB_LINK cSSLMsgBuilder : public cSSLMsg
        {
 
                typedef cSSLMsg SUPER_t;
 
        private:
                bool m_bCompleteMsg;            
                BYTE* m_pContApp;                       
 
        public:
                size_t m_nIntIndex;                     
                cSSLCtr m_Ctr;                          
 
        public:
                cSSLMsgBuilder();
                ~cSSLMsgBuilder();
 
                const BYTE* get_Ctr() const noexcept
                {
                        return m_Ctr.get_Ctr();
                }
 
                BYTE* get_ContApp() const noexcept
                {
                        return m_pContApp;
                }
                void put_ContAppIvSize(size_t nSizeIv)
                {
                        m_pContApp = get_Cont0() + nSizeIv;
                }
 
                bool isCompleteMsg() const noexcept
                {
                        return m_bCompleteMsg;
                }
                void SetCompleteMsg() noexcept
                {
                        // We now have a complete message.
                        m_bCompleteMsg = true;
                        m_nIntIndex = 0;        // may now read it read the start.
                }
 
                bool InitMsg();
                void ResetMsg(bool bHandshake)
                {
                        // We are done with this buffer. reset it for re-use.
                        // We do NOT have a complete message.
                        SUPER_t::ResetMsg();
                        m_bCompleteMsg = false;
                        m_nIntIndex = 0;
                        if (bHandshake)
                        {
                                m_pContApp = get_Cont0();  // SSL_VER_TLS_1_1 may move this.
                        }
                        // Leave m_Ctr
                }
 
                void UpdateHashV3(cHashWrap& rHasher, const BYTE* pSecret);
                void UpdateHmac(cHashWrap& rHasher, bool bEncrypt);
                void UpdateHmacExtra(cHashWrap& rHasher, size_t nSizePad, BYTE nCorrect);
 
                HRESULT ReadFill(cStreamInput* pReader, size_t nSizeExpect);
                HRESULT WriteFlush(cStreamOutput* pWriter, bool bWait);
        };
 
};
#endif