cKeyExDHM.h

Go to the documentation of this file.

//
//
#ifndef _INC_cKeyExDHM_H
#define _INC_cKeyExDHM_H
 
#include "cKeyExBase.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cKeyExDHM);
 
        class GRAYLIB_LINK cKeyExDHM : public cKeyExBase
        {
 
        public:
                static const char* k_pszPEM; // = "DH PARAMETERS";
 
                size_t m_len;                   
                cBigUnsigned m_P;     
                cBigInteger m_G;      
 
                cBigInteger m_GX;     
                cBigInteger m_GY;     
                cBigInteger m_K;      
 
                cBigUnsigned m_RP;    
                cBigInteger m_Vi;     
                cBigInteger m_Vf;     
                cBigInteger m_XPrev;     
 
                static const char* k_default_P;         
                static const char* k_default_G;         
 
        private:
                static HRESULT ReadBigIntSig(OUT cBigUnsigned& X, const BYTE* p, const BYTE* end);
                static bool IsValidDHM(const cBigUnsigned& param, const cBigUnsigned& P);
                HRESULT UpdateBlinding(IRandomNoise* pRandom);
 
        public:
                cKeyExDHM() noexcept
                        : m_len(0)
                {
                }
                ~cKeyExDHM()
                {
                        m_len = 0;
                }
 
                bool isKeyEx() const
                {
                        return m_len != 0;
                }
                bool isKeyValid() const
                {
                        return m_len >= 64 && m_len <= 512;
                }
 
                virtual HRESULT MakeKeyExParams(BYTE* pOut, size_t nSizeOut, IRandomNoise* pRandom) override;
 
                virtual HRESULT ReadKeyEx(const BYTE* pBuffer, const BYTE* end) override;
 
                virtual HRESULT ReadKeyPublic(const BYTE* pInput, size_t nSizeIn) override;
 
                HRESULT MakePublicDHM(size_t nSizeX, BYTE* pOutput, size_t nOutputSize, IRandomNoise* pRandom);
 
                //
                //
 
                HRESULT MakePrivateDHM(BYTE* pOutput, size_t* nOutputSize, IRandomNoise* pRandom);
 
                //
                HRESULT ReadFromBlock(const BYTE* dhmin, size_t dhminlen);
 
                HRESULT ReadFromFile(const FILECHAR_t* pszFilePath);
 
                UNITTEST_FRIEND(cKeyExDHM);
        };
}
 
#endif // cKeyExDHM