cSSLServer.h

Go to the documentation of this file.

//
//
#ifndef _INC_cSSLServer_H
#define _INC_cSSLServer_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cSSLCommon.h"
 
#if defined(USE_SSL_SERVER)
namespace GraySSL
{
        class cSSLTicketKeys;
        class cSSLServer;
 
        struct ISSLServerExt
        {
 
                virtual HRESULT OnCallback(cSSLServer* pSSL, const BYTE* pszName, size_t nSizeName) = 0;
        };
 
        class GRAYSSL_LINK cSSLServer : public cSSLCommon
        {
 
                typedef cSSLCommon SUPER_t;
 
        public:
                cSSLSessionCache* m_pCache;             
 
#if defined(USE_SSL_SESSION_TICKETS)
                // Support for generating and checking session tickets
                cNewPtr<cSSLTicketKeys> m_pTicketKeys;       
#endif // USE_SSL_SESSION_TICKETS
 
 
#if defined(USE_SSL_SERVER_NAME_INDICATION)
                ISSLServerExt* m_pSNICallback;
#endif
#if defined(USE_SSL_KeyExchange_PSK_SOME)
                ISSLServerExt* m_pPSKCallback;
#endif
 
        private:
                HRESULT state_SSL_ServerHello();
 
                HRESULT ReadSessionTicket(BYTE* buf, size_t len);
                HRESULT WriteSessionTicket(BYTE* pStart);
 
                const cSSLCipherSuite* FindCipherSuiteMatch(SSL_CipherSuite_TYPE eCipherSuite) const;
                HRESULT FindCipherSuite(const BYTE* pCiph, size_t nCiphLen, const cSSLCipherSuite** ppCipherSuite) const;
 
                size_t build_TLS_EXT_renegotiation_info(cSSLMsgHandExt* pExt);
                HRESULT parse_TLS_EXT_renegotiation_info(const BYTE* buf, size_t len);
 
#if defined(USE_SSL_KeyExchange_PSK_SOME)
                HRESULT parse_KeyEx_client_PSKIdentity(const BYTE* p, const BYTE* end);
#endif
#if defined(USE_SSL_KeyExchange_RSA) || defined(USE_SSL_KeyExchange_RSA_PSK)
                HRESULT parse_KeyEx_encrypted_pms(const BYTE* p, const BYTE* end, size_t pms_offset);
#endif
 
#if defined(USE_SSL_ECDH) || defined(USE_Key_ECDSA)
                HRESULT parse_TLS_EXT_supported_groups(const BYTE* buf, size_t len);
                HRESULT parse_TLS_EXT_ec_point_formats(const BYTE* buf, size_t len);
#endif
                HRESULT parse_TLS_EXT_MaxFragmentLength(const BYTE* buf, size_t len);
 
                HRESULT parse_TLS_EXT_EncryptThenMac(const BYTE* buf, size_t len);
 
#if defined(USE_SSL_SESSION_TICKETS)
                HRESULT parse_TLS_EXT_SessionTicket(BYTE* buf, size_t len);
#endif
 
                HRESULT parse_TLS_EXT_ExtendedMasterSecret(const BYTE* buf, size_t len);
                HRESULT parse_TLS_EXT_TruncatedHMAC(const BYTE* buf, size_t len);
 
                size_t build_TLS_EXT_ALPN(cSSLMsgHandExt* pExt);
                HRESULT parse_TLS_EXT_ALPN(const BYTE* buf, size_t len);
 
#if defined(USE_SSL_KeyExchange_Cert_SOME)
                HRESULT parse_TLS_EXT_signature_algorithms(const BYTE* buf, size_t len);
#endif
#if defined(USE_SSL_ECDH) || defined(USE_Key_ECDSA)
                size_t build_TLS_EXT_ec_point_formats(cSSLMsgHandExt* pExt);
#endif
 
                size_t build_TLS_EXT_TruncatedHMAC(BYTE* buf);
 
                size_t build_TLS_EXT_EncryptThenMac(BYTE* buf);
 
#if defined(USE_SSL_KeyExchange_DHE_RSA) ||  defined(USE_SSL_KeyExchange_DHE_PSK)
                HRESULT parse_KeyEx_client_dh_public(const BYTE* p, const BYTE* end);
#endif
 
        public:
                cSSLServer(const cSSLConfig& rOpts) noexcept;
                ~cSSLServer();
 
                virtual HRESULT ProcessStreamPacket() override; // process handshake.
 
#if defined(USE_SSL_SERVER_NAME_INDICATION)
                void put_SNICallback(ISSLServerExt* pSNICallback);
#endif // USE_SSL_SERVER_NAME_INDICATION
 
#if defined(USE_SSL_KeyExchange_PSK_SOME)
                void put_PSKCallback(ISSLServerExt* pPSKCallback);
#endif // USE_SSL_KeyExchange_PSK_SOME
 
#if defined(USE_SSL_KeyExchange_PSK_SOME)
                HRESULT SetPSKIdentity(const BYTE* psk, size_t psk_len, const BYTE* psk_identity, size_t psk_identity_len);
#endif
 
                HRESULT state_SSL_ClientHello();
                HRESULT parse_SSL_ClientHello_v2();
                HRESULT state_SSL_CERTIFICATE_REQUEST();
                HRESULT state_SSL_SERVER_KEY_EXCHANGE();
                HRESULT state_SSL_ServerHello_DONE();
                HRESULT state_SSL_CLIENT_KEY_EXCHANGE();
                HRESULT state_SSL_CERTIFICATE_VERIFY();
                HRESULT state_SSL_SERVER_CHANGE_CIPHER_SPEC();
                void state_SSL_HANDSHAKE_WRAPUP();
 
                HRESULT parse_TLS_EXT_server_name(const BYTE* buf, size_t len);
                size_t build_TLS_EXT_SessionTicket(cSSLMsgHandExt* pExt);
                size_t build_TLS_EXT_ExtendedMasterSecret(cSSLMsgHandExt* pExt);
 
                void put_SessionCache(cSSLSessionCache* pCache)
                {
                        this->m_pCache = pCache;
                }
 
#if defined(USE_SSL_SESSION_TICKETS)
                HRESULT put_UseSessionTickets(bool bUseTickets);
#endif
                HRESULT AddKeyCrt(cX509KeyCrtPair* pKeyCrt);
 
        };
}
#endif // USE_SSL_SERVER
#endif