cSecureChannel.h

Go to the documentation of this file.

//
//
#ifndef _INC_cSecureChannel_H
#define _INC_cSecureChannel_H 0x1D // This is the version stamp for the protocol
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Net/cProtocol.h"
#include "../UID/cFourCC.h"
#include "../Hash/cHashSHA256.h"
#include "../Cipher/cCipherBase.h"
#include "../Codec/cStreamCipher.h"
#include "GrayCore/include/cArchive.h"
#include "GrayCore/include/StrA.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSecureChannel);
        typedef cHashSHA256 cSecureHash;        
 
        class GRAYLIB_LINK cSecureId
        {
 
        public:         
                cStringA m_sAppId;              
                cStringA m_sUserId;             
 
        public:
                cSecureId(cStringA sAppId = "", cStringA sUserId = "") noexcept
                : m_sAppId(sAppId)
                , m_sUserId(sUserId)
                {
                }
                bool IsSame(const cSecureId& k) const
                {
                        if (m_sAppId.Compare(k.m_sAppId))
                                return false;
                        if (m_sUserId.Compare(k.m_sUserId))
                                return false;
                        return true;
                }
        };
 
        class GRAYLIB_LINK cSecureKnock : public cSecureId
        {
        public:
                typedef cSecureId SUPER_t;
 
                enum CIPHER_TYPE
                {
                        CIPHER_None = 0,        
                        CIPHER_RC4,                     
                        CIPHER_Blowfish,        
                        CIPHER_AES,                     
 
                        // Other future crypto...
                        CIPHER_QTY,
 
                        CIPHER_KEY_RSA = 31,            
                };
 
                static const FOURCC k_SIGNATURE = MAKEFOURCC('G', 'S', 'e', 'c');       
                static const size_t k_SizeMin = 14;             
 
                FOURCC m_nSignature;            
                WORD m_nVersion;                        
                WORD m_nCryptAbilities;         
 
        public:
 
                cSecureKnock(cStringA sAppId = "", cStringA sUserId = "", WORD nCryptAbilities = _1BITMASK(CIPHER_RC4) | _1BITMASK(CIPHER_None))
                : cSecureId(sAppId, sUserId)
                , m_nSignature(k_SIGNATURE)
                , m_nVersion(_INC_cSecureChannel_H)
                , m_nCryptAbilities(nCryptAbilities)    // CIPHER_TYPE
                {
                }
 
                HRESULT Serialize(cArchive& a);
                HRESULT SetSecureKnock(cStreamInput& s);
                HRESULT SetSecureKnock(const void* pData, size_t nSize);
 
                void SetClear() noexcept
                {
                        m_nSignature = 0;
                        m_nVersion = 0;
                }
                bool IsSame(const cSecureKnock& k) const;
        };
 
        class GRAYLIB_LINK cSecureChannel
        {
 
        public:
                enum STATE_TYPE
                {
                        STATE_0 = 0,            
                        Client_Knock,           
                        Server_Challenge,       
                        Client_Login,           
                        STATE_Secure,           
                        STATE_Failed,           
                };
 
        public:
                cHashCode m_Challenge;  
                cHashCode m_HashPass;   
                cSecureId m_Id;                 
 
        protected:
                STATE_TYPE m_eState;    
                cSecureKnock::CIPHER_TYPE m_eCipherType;        
                cNewPtr<cCipherBase> m_pCipherEnc;      
                cNewPtr<cStreamCipherEnc> m_pCipherOut; 
                cNewPtr<cCipherBase> m_pCipherDec;      
                cNewPtr<cStreamCipherDec> m_pCipherInp; 
 
        protected:
                virtual HRESULT SetStateSecure();
                HRESULT GetCipher(OUT cNewPtr<cCipherBase>& rCipher, bool bEncodeMode, const cSecureHash& hashKey);
 
        public:
                cSecureChannel();
                virtual ~cSecureChannel();
 
                STATE_TYPE get_State() const noexcept
                {
                        return m_eState;
                }
                bool isStateSecure() const noexcept
                {
                        return get_State() == STATE_Secure;
                }
 
                cStreamInput* get_SecureInp() const;
                cStreamOutput* get_SecureOut() const;
 
                static void GRAYCALL ComputeHash(OUT cSecureHash& rHash, const cHashCode& r1, const cHashCode& r2);
 
                UNITTEST_FRIEND(cSecureChannel);
        };
 
        class GRAYLIB_LINK cSecureClient : public cSecureChannel
        {
 
                typedef cSecureChannel SUPER_t;
 
        protected:
                cStreamInput* m_pStreamInp;             
                cStreamOutput* m_pStreamOut;    
 
        private:
                HRESULT OnState0();
                HRESULT OnStateKnock();
                HRESULT OnStateLogin();
 
        public:
                cSecureClient(cStreamInput* pStreamInp, cStreamOutput* pStreamOut);
                virtual ~cSecureClient();
 
                HRESULT AdvanceState();
 
                cStreamInput* get_SecureInp() const
                {
                        if (m_pCipherInp == nullptr)    // From the raw channel. CIPHER_None = No Crypt. Pass Through.
                                return m_pStreamInp;
                        return SUPER_t::get_SecureInp();
                }
                cStreamOutput* get_SecureOut() const
                {
                        if (m_pCipherOut == nullptr)    // From the raw channel. CIPHER_None = No Crypt. Pass Through.
                                return m_pStreamOut;
                        return SUPER_t::get_SecureOut();
                }
        };
 
        class GRAYLIB_LINK cSecureServerFactory;
 
        class GRAYLIB_LINK cSecureServerStream : public cRefBase, public cSecureChannel, public cProtocolStream
        {
 
                friend class cSecureServerFactory;
 
        public:
                static const size_t k_ChallengeSize = cSecureHash::k_Size;              
                cProtocolStreamPtr m_pProtocol2;                
 
        private:
                HRESULT SendFailState0(HRESULT hResRet);
                HRESULT OnState0();
                HRESULT OnStateChallenge();
                HRESULT OnStateSecure();
 
        public:
                cSecureServerStream(cSecureServerFactory* pFactory, IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut);
                virtual ~cSecureServerStream();
 
                IUNKNOWN_DISAMBIG(cRefBase);
 
                virtual HRESULT DisposeThis() override;
 
                HASHCODE_t get_HashCode() const noexcept
                {
                        return cProtocolStream::get_HashCode();
                }
                STDMETHOD_(HASHCODE_t, get_HashCodeX)() const noexcept override
                {
                        return cProtocolStream::get_HashCode();
                }
 
                cStreamInput* get_SecureInp() const
                {
                        if (m_pCipherInp == nullptr)    // From the raw channel. CIPHER_None = No Crypt. Pass Through.
                                return cProtocolStream::get_StreamInp();
                        return cSecureChannel::get_SecureInp();
                }
                cStreamOutput* get_SecureOut() const
                {
                        if (m_pCipherOut == nullptr)    // From the raw channel. CIPHER_None = No Crypt. Pass Through.
                                return cProtocolStream::get_StreamOut();
                        return cSecureChannel::get_SecureOut();
                }
 
                virtual HRESULT SetStateSecure();
                virtual HRESULT ProcessStreamPacket() override;
        };
        typedef cRefPtr<cSecureServerStream> cSecureServerStreamPtr;
 
        class GRAYLIB_LINK cSecureServerFactory : public IProtocolFactory
        {
 
        protected:
                cProtocolFactories m_Factories;         
 
        public:
                virtual const char* get_ProtocolName() const override
                {
                        return "GSec";
                }
                virtual HRESULT TestProtocol(const BYTE* pszPrefixData, size_t iPrefixLen) const override
                {
                        cSecureKnock knock;
                        const HRESULT hRes = knock.SetSecureKnock(pszPrefixData, iPrefixLen);
                        return hRes;
                }
                virtual cProtocolStreamPtr CreateProtocolStream(IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut) override
                {
                        return new cSecureServerStream(this, pServerConnection, pStreamInp, pStreamOut);
                }
                virtual HRESULT FindChallengeMatch(cSecureServerStream* pStream, const void* pData, size_t nDataSize);
        };
};
#endif // _INC_cSecureChannel_H