cECPGroupParams.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cECPGroupParams_H
#define _INC_cECPGroupParams_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Math/cBigInteger.h"
 
namespace GrayLib
{
        class cASNReader;
 
        enum ECP_CurveType_t
        {
                ECP_CurveType_NONE = 0,
                ECP_CurveType_SHORT_WEIERSTRASS,    // 4 in ReadPointBinary? = // y^2 = x^3 + a x + b
                ECP_CurveType_MONTGOMERY,           // ? = // y^2 = x^3 + a x^2 + x (ECPGroup_x25519) NOT WORKING
        };
 
        enum ECPGroup_TYPE
        {
 
#define ECPGROUPTYPEDEF(a,b,c,d,e)              ECPGroup_##a = c,
#include "cECPGroupTypes.tbl"
#undef ECPGROUPTYPEDEF
        };
 
        class GRAYLIB_LINK cECPPoint
        {
 
        public:
                cBigInteger m_X;          
                cBigInteger m_Y;          
                cBigInteger m_Z;          
 
        public:
                cECPPoint()
                {
                }
                ~cECPPoint()
                {
                }
 
                void SetEmptyPoint()
                {
                        m_X.SetNullVal();
                        m_Y.SetNullVal();
                        m_Z.SetNullVal();
                }
 
                bool IsEqualPoint(const cECPPoint& ref) const
                {
                        if (!m_X.IsEqual(ref.m_X))
                                return false;
                        if (!m_Y.IsEqual(ref.m_Y))
                                return false;
                        if (!m_Z.IsEqual(ref.m_Z))
                                return false;
                        return true;
                }
 
                bool isZeroPoint() const
                {
                        return this->m_Z.isZero();
                }
 
                bool IsMatchParams(const cECPPoint& ref) const;
                void SetPointNormal();
 
                void SetCopyPoint(const cECPPoint& Q);
 
                bool SetPointFromStr(RADIX_t radix, const char* x, const char* y);
 
                HRESULT WritePointBinary(BYTE* pBuf, size_t nSizeBuffer, size_t nSizeP, bool bCompressed) const;
 
                HRESULT WritePointLen(BYTE* pBuf, size_t nSizeBuffer, size_t nSizeP, bool bCompressed) const;
 
                HRESULT ReadPointBinary(size_t nSizeP, const BYTE* pBuf, size_t nSizeBuffer);
 
                HRESULT ReadPointLen(size_t nSizeP, const BYTE* pBuf, size_t nSizeBuffer);
 
                HRESULT ReadPointASN(size_t nSizeP, cASNReader& r0);
        };
 
        class GRAYLIB_LINK cECPGroupParams
        {
 
                typedef cECPGroupParams THIS_t;
 
        public:
 
                static const char* k_pszPEM;    
 
                static const WORD k_ECP_MAX_BITS = 521;   
                static const WORD k_ECP_MAX_BYTES = GETSIZEBYTES(k_ECP_MAX_BITS);
 
                // d = ceil( n / w )
                static const WORD k_COMB_MAX_D = (k_ECP_MAX_BITS + 1) / 2;
 
                cBigInteger m_P;            
                BIT_ENUM_t m_nPBits;            
 
                cBigInteger m_A;            
                cBigInteger m_B;            
 
                cECPPoint m_G;                          
 
                cBigInteger m_N;            
                BIT_ENUM_t m_nNBits;            
 
        public:
                cECPGroupParams()
                        : m_nPBits(0)
                        , m_nNBits(0)
                {
                }
 
                ECP_CurveType_t get_ECP_CurveType() const
                {
                        if (this->m_G.m_X.isNullVal())
                                return ECP_CurveType_NONE;
                        if (this->m_G.m_Y.isNullVal())
                                return ECP_CurveType_MONTGOMERY;
                        return ECP_CurveType_SHORT_WEIERSTRASS;
                }
 
                size_t get_SizeP() const
                {
                        return m_P.get_BinarySize();
                }
 
                void inline DoModPLo(OUT cBigInteger& N) const
                {
                        while (N.isNegative())
                        {
                                N.InitAdd(N, this->m_P);
                        }
                }
                void inline DoModPHi(OUT cBigInteger& N) const
                {
                        while (N.Compare(this->m_P) >= 0)
                        {
                                N.InitSubU(N, this->m_P);
                        }
                }
 
                bool IsMatchECPParams(const cECPGroupParams& ref) const;
                HRESULT IsValidPrivateKey(const cBigUnsigned& d) const;
 
                void UpdateBits();
                void InjectCommon();
                HRESULT SetCopyECP(const THIS_t& rSrc);
                void SetEmptyECPGroup();
 
                HRESULT ReadSpecifiedECDomain(cASNReader& r);
                HRESULT SetECPGroupFromStr(RADIX_t radix, const char* p, const char* b, const char* gx, const char* gy, const char* n); // NOT USED.
                HRESULT ReadBigIntECDSA(OUT cBigInteger& x, const BYTE* buf, size_t nSizeBuffer) const;
        };
}
 
#endif