cRandomDSA.h

Go to the documentation of this file.

//
//
#ifndef _INC_cRandomDSA_H
#define _INC_cRandomDSA_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Hash/cHashCode.h"
#include "GrayCore/include/cRandom.h"
#include "GrayLib/include/Hash/cHashWrap.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cRandomDSA);
 
        class GRAYLIB_LINK cRandomMixerBase : public IRandomNoise
        {
        public:
                int m_nReSeedCounter;           
                bool m_bPredictionResistance;   
                size_t m_nEntropyLen;                   
                int m_nReSeedInterval;                  
                IRandomNoise* m_pRandom;        
 
        public:
                cRandomMixerBase() noexcept
                        : m_nReSeedCounter(0)
                        , m_bPredictionResistance(false)
                        , m_nEntropyLen(0)
                        , m_nReSeedInterval(0)
                        , m_pRandom(nullptr)
                {
                }
                virtual ~cRandomMixerBase()
                {
                }
 
                inline void put_PredictionResistance(bool bPredictionResistance) noexcept
                {
                        this->m_bPredictionResistance = bPredictionResistance;
                }
        };
 
        class GRAYLIB_LINK cRandomDSA : public cRandomMixerBase // IRandomNoise
        {
        public:
                cHashWrap m_HashCtx;                    
                BYTE m_V[cHashWrap::k_HashSizeMax];  
 
        public:
                cRandomDSA() noexcept
                {
                        SetZeroHmac();
                }
                ~cRandomDSA()
                {
                        cMem::ZeroSecure(m_V, sizeof(m_V));
                }
 
                void SetZeroHmac() noexcept
                {
                        // m_HashCtx.SetZeroHash();
                        cMem::Zero(m_V, sizeof(m_V));
                }
 
                HRESULT InitRandomHmac(const cHashTypeDef* pHashType, const BYTE* data, size_t data_len);
 
                virtual HRESULT GetNoise(void* pOut, size_t out_len) override;
 
                void UpdateRandomReseed2(const BYTE* pAddData, size_t add_len);
 
                //
                HRESULT UpdateRandomReseed1(const BYTE* pAddData, size_t add_len);
 
                UNITTEST_FRIEND(cRandomDSA);
        };
}
 
#endif // _INC_cRandomDSA_H