cECPGroup.h

Go to the documentation of this file.

//
//
#ifndef _INC_cECPGroup_H
#define _INC_cECPGroup_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cECPGroupDef.h"
#include "../File/cASNReader.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cECPGroup);
 
        struct cECPStats
        {
                // stats for testing
                ULONG m_add_count;
                ULONG m_dbl_count;
                ULONG m_mul_count;
 
                void SetCounts0() noexcept
                {
                        m_add_count = 0;
                        m_dbl_count = 0;
                        m_mul_count = 0;
                }
        };
 
        class GRAYLIB_LINK cECPGroup : public cECPGroupParams
        {
 
                typedef cECPGroupParams SUPER_t;
 
        public:
 
                // Maximum "window" size used for point multiplication.
                // Default: 6.
                // Minimum value: 2. Maximum value: 7.
                //
                // Result is an array of at most ( 1 << ( k_ECP_WINDOW_SIZE - 1 ) )
                // points used for point multiplication. This value is directly tied to EC
                // peak memory usage, so decreasing it by one should roughly cut memory usage
                // by two (if large curves are in use).
                //
                // Reduction in size may reduce speed, but larger curves are impacted first.
                // Sample performances (in ECDHE handshakes/s, with FIXED_POINT_OPTIM = 1):
                //      w-size:     6       5       4       3       2
                //      521       145     141     135     120      97
                //      384       214     209     198     177     146
                //      256       320     320     303     262     226
                //
                //      224       475     475     453     398     342
                //      192       640     640     633     587     476
 
                static const int k_ECP_WINDOW_SIZE = 6;         
                static cECPStats sm_ECPStats;           // for testing
 
                const cECPGroupDef* m_pECPGroupDef;                     
 
                mutable cArrayStruct<cECPPoint> m_aT;                   
 
        protected:
 
                HRESULT DoModP(OUT cBigInteger& N) const;
 
                HRESULT DoMulModP(OUT cBigInteger& X, const cBigInteger& Y, const cBigInteger& Z) const
                {
                        X.InitMultiply(Y, Z);
                        return this->DoModP(X);
                }
 
                HRESULT DoAddMixed(OUT cECPPoint& R, const cECPPoint& P, const cECPPoint& Q) const;
 
                HRESULT Mxz_normalize(cECPPoint& P) const;
                HRESULT Mxz_randomize(cECPPoint& P, IRandomNoise* pRandom) const;
                HRESULT Mxz_add_double(cECPPoint& R, cECPPoint& S, const cECPPoint& P, const cECPPoint& Q, const cBigInteger& d) const;
                HRESULT Mxz_mul(cECPPoint& R, const cBigInteger& m, const cECPPoint& P, IRandomNoise* pRandom) const;
 
                HRESULT Jac_normalize(cECPPoint& pt) const;
                HRESULT Jac_normalize_many(cECPPoint* pT[], ITERATE_t t_len) const;
                HRESULT Jac_double(cECPPoint& R, const cECPPoint& P) const;
                HRESULT Jac_randomize(cECPPoint& pt, IRandomNoise* pRandom) const;
                HRESULT Jac_safe_invert(cECPPoint& Q, bool inv) const;
 
                static void Comb_fixed(BYTE x[], size_t d, BYTE w, const cBigInteger& m);
 
                HRESULT Comb_precompute(cECPPoint T[], const cECPPoint& P, BYTE w, size_t d) const;
                HRESULT Comb_mul_core(cECPPoint& R, const cECPPoint T[], BYTE t_len, const BYTE x[], size_t d, IRandomNoise* pRandom) const;
                HRESULT Comb_mul(OUT cECPPoint& R, const cBigUnsigned& m, const cECPPoint& P, IRandomNoise* pRandom) const;
                HRESULT Comb_select(cECPPoint& R, const cECPPoint T[], BYTE t_len, BYTE i) const;
 
                HRESULT DoAdd(OUT cECPPoint& R, const cECPPoint& P, const cECPPoint& Q) const;
                HRESULT DoSub(cECPPoint& R, const cECPPoint& P, const cECPPoint& Q) const; // NOT USED
 
                HRESULT IsValidPublicKeyWS(const cECPPoint& pt) const;
                HRESULT IsValidPublicKeyMX(const cECPPoint& pt) const;
 
        public:
                cECPGroup() noexcept
                        : m_pECPGroupDef(nullptr)
                {
                }
                ~cECPGroup()
                {
                        SetEmptyECPGroup();
                }
 
                void SetEmptyECPGroup();
 
                ECPGroup_TYPE get_ECPGroupId() const noexcept
                {
                        if (m_pECPGroupDef == nullptr)
                                return ECPGroup_NONE;
                        return m_pECPGroupDef->m_eECPGroupId;
                }
                const cECPGroupDef* get_ECPGroupDef() const noexcept
                {
                        return m_pECPGroupDef;
                }
 
                HRESULT put_ECPGroupDef(const cECPGroupDef* pECPGroupDef);
                HRESULT put_ECPGroupId(ECPGroup_TYPE eECPGroupId);
                HRESULT SetECParameters(const cASNBuf& params);
 
                HRESULT DoMult(OUT cECPPoint& R, const cBigUnsigned& m, const cECPPoint& P, IRandomNoise* pRandom) const;
 
                HRESULT SetCopyECP(const cECPGroup& rSrc);
 
                HRESULT GenerateKeys(cBigUnsigned& d, cECPPoint& Q, IRandomNoise* pRandom) const;
 
                HRESULT IsValidPublicKey(const cECPPoint& pt) const;
 
                HRESULT MakeSignatureECDSA(OUT cBigInteger& r, OUT cBigInteger& s, const cBigInteger& d, const BYTE* buf, size_t nSizeBuffer, IRandomNoise* pRandom) const;
                HRESULT VerifySignatureECDSA(const BYTE* buf, size_t nSizeBuffer, const cECPPoint& Q, const cBigInteger& r, const cBigInteger& s) const;
 
                UNITTEST_FRIEND(cECPGroup);
        };
}
 
#endif