cKeyECPPair.h

Go to the documentation of this file.

//
//
#ifndef _INC_cKeyECPPair_H
#define _INC_cKeyECPPair_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cKeyBase.h"
#include "cKeyTypeDef.h"
#include "cECPGroup.h"
#include "../Hash/cHashWrap.h"
#include "../File/cASNReader.h"
#include "../File/cASNWriterRev.h"
#include "../Math/cBigInteger.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cKeyECPPair);
 
        class GRAYLIB_LINK cKeyECPPair : public cKeyBase
        {
                typedef cKeyBase SUPER_t;
 
        public:
                cECPGroup m_grp;      
                cBigInteger m_d;      
                cECPPoint m_Q;        
 
        protected:
                static HRESULT GRAYCALL ReadECParameters(cASNReader& r, OUT cASNBuf& params);
 
                HRESULT MakeSignatureSeed(BYTE* pOut, const cBigInteger& d, const BYTE* buf, size_t nSizeBuf) const;
                HRESULT MakeSignatureDer(cASNWriterRev& w, const cBigInteger& r, const cBigInteger& s) const;
 
        public:
                cKeyECPPair() noexcept
                {
                }
                virtual ~cKeyECPPair()
                {
                }
 
                virtual size_t get_KeySize() const override
                {
                        return cBits::GetSizeBytes(this->m_grp.m_nPBits);
                }
 
                virtual int GetKeyValues(cValue* items) const override
                {
                        items->m_eValueType = cKeyBase::VALTYPE_ECP;
                        items->m_pszName = "eckey.Q";
                        items->m_pValue = &(this->m_Q);
                        return 1;
                }
 
                virtual void SetZeroKey() override
                {
                        m_grp.SetEmptyECPGroup();
                        m_d.SetNullVal();
                        m_Q.SetEmptyPoint();
                }
 
                void SetCopyKey(const cKeyECPPair& key)
                {
                        this->m_grp.SetCopyECP(key.m_grp);
                        this->m_d.SetCopyInt(key.m_d);
                        this->m_Q.SetCopyPoint(key.m_Q);
                }
 
                virtual HRESULT CheckPublicPrivatePair(const cKeyBase* pKeyPrivate) const override;
                virtual HRESULT VerifySignature(SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, const BYTE* pSig, size_t nSizeSig) const override;
                virtual HRESULT MakeSignature(BYTE* pSig, SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, IRandomNoise* pRandom) const override;
 
                HRESULT GenerateKeys(ECPGroup_TYPE eECPGroupId, IRandomNoise* pRandom);
                HRESULT WriteECParameters(cASNWriterRev& w) const;
 
                virtual HRESULT ReadPrivateKey(cASNReader& r, cASNBuf* pAlgParams) override;
                virtual HRESULT ReadPublicKey(cASNReader& r, cASNBuf* pAlgParams) override;
 
                virtual HRESULT WritePrivateKey(cASNWriterRev& w) const override;
                virtual HRESULT WritePublicKey(cASNWriterRev& w) const override;
 
                UNITTEST_FRIEND(cKeyECPPair);
        };
 
        class GRAYLIB_LINK cKeyTypeEC : public cKeyTypeDef
        {
                typedef cKeyTypeDef SUPER_t;
        public:
                cKeyTypeEC() noexcept
                        : cKeyTypeDef(SSL_Key_ECKEY, "EC")
                {
                }
                cKeyTypeEC(SSL_Key_TYPE eKeyType, const char* name)
                        : cKeyTypeDef(eKeyType, name)
                {
                }
                virtual bool HasKeyType(SSL_Key_TYPE eKeyType) const noexcept
                {
                        return eKeyType == SSL_Key_ECKEY || eKeyType == SSL_Key_ECKEY_DH || eKeyType == SSL_Key_ECDSA ;
                }
                virtual cKeyBase* AllocKey() const
                {
                        return new cKeyECPPair();
                }
        };
 
        class GRAYLIB_LINK cKeyTypeECDH : public cKeyTypeEC
        {
                typedef cKeyTypeEC SUPER_t;
        public:
                cKeyTypeECDH()
                        : cKeyTypeEC(SSL_Key_ECKEY_DH, "EC_DH")
                {
                }
                virtual bool HasKeyType(SSL_Key_TYPE eKeyType) const noexcept
                {
                        return eKeyType == SSL_Key_ECKEY || eKeyType == SSL_Key_ECKEY_DH ;
                }
        };
}
 
#endif // _INC_cKeyECP_H