cSSLHandshake.h

Go to the documentation of this file.

//
//
#ifndef _INC_cSSLHandshake_H
#define _INC_cSSLHandshake_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GraySSLInt.h"
#include "GrayLib/include/SSL/cSSLCipherSuite.h"
#include "GrayLib/include/Cert/cX509KeyCrtPair.h"
 
#if defined(USE_SSL_DHM)
#include "GrayLib/include/KeyEx/cKeyExDHM.h"
#endif
#if defined(USE_SSL_ECDH)
#include "GrayLib/include/KeyEx/cKeyExECDH.h"
#endif
 
#include "GrayLib/include/Key/cECPGroupPrefs.h"
#include "GrayLib/include/Hash/cHashMD5.h"
#include "GrayLib/include/Hash/cHashSHA1.h"
#include "GrayLib/include/Hash/cHashSHA256.h"
#include "GrayLib/include/Hash/cHashSHA512.h"
#include "GrayLib/include/SSL/cSSL.h"
 
namespace GraySSL
{
        class cSSLCommon;
 
        // cKeyExPremasterSecret
 
        union uSSLPremasterSecret 
        {
 
#if defined(USE_SSL_KeyExchange_RSA)
                BYTE m_rsa[48];                                                         // RFC 5246 8.1.1 - k_MAC_Size_Max
#endif
#if defined(USE_SSL_KeyExchange_DHE_RSA)
                BYTE m_dhm[cSSL::k_Number_Size_Max];            // RFC 5246 8.1.2 - 3072 bits is a reasonable max.
#endif
#if defined(USE_SSL_KeyExchange_ECDHE_RSA)    || \
        defined(USE_SSL_KeyExchange_ECDHE_ECDSA)  || \
        defined(USE_SSL_KeyExchange_ECDH_RSA)     || \
        defined(USE_SSL_KeyExchange_ECDH_ECDSA)
                BYTE m_ecdh[cECPGroupParams::k_ECP_MAX_BYTES];          // RFC 4492 5.10
#endif
#if defined(USE_SSL_KeyExchange_PSK)
                BYTE m_psk[4 + 2 * cSSL::k_PSK_Size_Max];                       // RFC 4279 2 - SSL_KeyExchange_PSK
#endif
#if defined(USE_SSL_KeyExchange_DHE_PSK)
                BYTE m_dhe_psk[4 + cSSL::k_Number_Size_Max + cSSL::k_PSK_Size_Max];       // RFC 4279 3
#endif
#if defined(USE_SSL_KeyExchange_RSA_PSK)
                BYTE m_rsa_psk[52 + cSSL::k_PSK_Size_Max];                      // RFC 4279 4
#endif
#if defined(USE_SSL_KeyExchange_ECDHE_PSK)
                BYTE m_ecdhe_psk[4 + cECPGroupParams::k_ECP_MAX_BYTES + cSSL::k_PSK_Size_Max];     // RFC 5489 2
#endif
        };
 
        DECLARE_INTERFACE(ISSLHandshakeHasher)
        {
                IGNORE_WARN_INTERFACE(ISSLHandshakeHasher);
                virtual HRESULT CalcBegin(BYTE* pOutput, size_t dlen, const BYTE* secret, size_t slen, const char* pszLabel, const BYTE* random, size_t rlen) const = 0;
                virtual void CalcVerify(const cSSLCommon* pSSL, BYTE* pHash) const = 0;
                virtual void CalcFinished(const cSSLCommon* pSSL, BYTE* pBuffer, bool bEndpointIsServer) const = 0;
        };
 
        class GRAYSSL_LINK cSSLHandshake : public cSSL
        {
 
        public:
                SSL_Hash_TYPE m_eSignHashType;         
                SSL_CERT_TYPE m_eCertType;             
                SSL_Hash_TYPE m_eHashTypeVerify;       
 
                // cKeyExBase
#if defined(USE_SSL_DHM)
                cKeyExDHM m_KeyExchDHM;                
#endif
#if defined(USE_SSL_ECDH)
                cKeyExECDH m_KeyExchECDH;              
#endif
 
#if defined(USE_SSL_ECDH) || defined(USE_Key_ECDSA)
                cECPGroupPrefs m_ECPGroups;                             
#endif
 
#if defined(USE_SSL_X509_CRT_PARSE)
                cX509KeyCrtPair* m_pKeyCrtHand;
#if defined(USE_SSL_SERVER_NAME_INDICATION)
                cX509KeyCrtPair* m_pKeyCrtSNI;         
#endif
#endif // USE_SSL_X509_CRT_PARSE
 
                // UpdateHandHashes contexts
#if defined(USE_SSL_VER_SSL_3) || defined(USE_SSL_VER_TLS_1_0) || defined(USE_SSL_VER_TLS_1_1)
                cHashMD5Builder m_fin_md5;
                cHashSHA1Builder m_fin_sha1;
#endif
                cHashSHA256Builder m_fin_sha256;
                cHashSHA384Builder m_fin_sha384;
 
                const ISSLHandshakeHasher* m_pHasher;   
 
                SSL_Hash_TYPE m_eHashChecksum;
 
                BYTE m_randbytes[64];                                   
 
                BYTE m_premaster[sizeof(uSSLPremasterSecret)];  
                size_t m_nPremasterLen;                                 
 
                bool m_bResume;                         
                SSL_VERSION_TYPE m_nVerMax;             
 
                bool m_bTLS_EXT;                                                
 
#if defined(USE_SSL_SESSION_TICKETS)
                bool m_bNewSessionTicket;                               
#endif // USE_SSL_SESSION_TICKETS
 
                bool m_bExtendedMasterSecret;                   
 
        public:
                cSSLHandshake();
                ~cSSLHandshake();
 
#if defined(USE_SSL_ECDH) || defined(USE_Key_ECDSA)
                HRESULT ReadGroupDefs(UINT nGroupQty, const BYTE* p);
#endif
 
                void SetHasherVer1(SSL_VERSION_TYPE eVer, const cSSLCipherSuite* pCipherSuite);
                bool SetHasherVer2(SSL_VERSION_TYPE eVer, const cSSLCipherSuite* pCipherSuite);
                void UpdateHandHashes(const BYTE* buf, size_t len);
 
#if defined(USE_SSL_X509_CRT_PARSE)
                bool SelectKeyCrt(const cSSLCipherSuite* pCipherSuite, SSL_VERSION_TYPE nVer);
#endif
 
        };
}
 
#endif