cKeyRSA.h

Go to the documentation of this file.

//
//
#ifndef _INC_cKeyRSA_H
#define _INC_cKeyRSA_H
 
#include "cKeyBase.h"
#include "cKeyRSA1.h"
#include "../Hash/cHashWrap.h"
#include "../Key/cKeyTypeDef.h"
#include "../File/cASNReader.h"
#include "../File/cASNWriterRev.h"
#include "../Math/cBigUnsigned.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cKeyRSA);
 
        enum PKCS1_VER_TYPE
        {
                PKCS1_VER_15 = 0,
                PKCS1_VER_21 = 1,
        };
 
        class GRAYLIB_LINK cKeyRSASignOptions
        {
        public:
                SSL_Hash_TYPE m_eHashTypeMGF1;  // mgf1 = maskGenAlgorithm
                int m_nSizeSaltExpected;
        public:
                cKeyRSASignOptions(SSL_Hash_TYPE eHashType = SSL_Hash_SHA1, size_t nSizeSalt = 20) noexcept
                        : m_eHashTypeMGF1(eHashType)
                        , m_nSizeSaltExpected((int)nSizeSalt)
                {
                }
                HRESULT ReadHashAlg(const cASNBuf& alg);
                HRESULT ReadRsaSsaPssParams(const cASNBuf& params, OUT SSL_Hash_TYPE& eSignHashType);
        };
 
        class GRAYLIB_LINK cKeyRSA : public cKeyBase, public cKeyRSA1
        {
 
        public:
                static const int k_nSizeSaltAny = -1;
 
                size_t m_nSizeBlock;                    
                PKCS1_VER_TYPE m_ePadding;              
                SSL_Hash_TYPE m_eHashType;              
 
                // Support for private key. Stored in RSAPrivateKey ::= SEQUENCE
                VAL_t m_D;                      
                VAL_t m_P;                      
                VAL_t m_Q;                      
 
                VAL_t m_DP;                     
                VAL_t m_DQ;                     
                VAL_t m_QP;                     
 
                // Work data.
                mutable cThreadLockMutex m_Mutex;    
 
                mutable VAL_t m_RN;                     
                mutable VAL_t m_RP;                     
                mutable VAL_t m_RQ;                     
 
                mutable VAL_t m_BlindAdd;               
                mutable VAL_t m_BlindRemove;            
 
        protected:
                HRESULT CreateBlindingValues(IRandomNoise* pRandom) const;
 
        public:
                cKeyRSA(PKCS1_VER_TYPE ePadding = PKCS1_VER_15, SSL_Hash_TYPE eHashType = SSL_Hash_NONE);
                virtual ~cKeyRSA();
 
                bool IsValidPrivateKey() const;
 
                virtual size_t get_KeySize() const override
                {
                        return this->m_nSizeBlock;
                }
                virtual int GetKeyValues(cValue* items) const override
                {
                        items->m_eValueType = cKeyBase::VALTYPE_RSA;
                        items->m_pszName = "rsa.N";
                        items->m_pValue = &(this->m_N);
 
                        items++;
                        items->m_eValueType = cKeyBase::VALTYPE_RSA;
                        items->m_pszName = "rsa.E";
                        items->m_pValue = &(this->m_E);
                        return 2;
                }
 
                virtual void SetZeroKey() override;
                void SetCopyKey(const cKeyRSA& src);
 
                HRESULT DoRSAPublic(BYTE* pOutput, const BYTE* pInput) const;
                HRESULT DoRSAPrivate(BYTE* pOutput, const BYTE* pInput, IRandomNoise* pRandom) const;
 
        protected:
                // PKCS1_VER_15
                HRESULT EncryptWithKeyV15(BYTE* pOutput, const BYTE* pInput, size_t nSizeIn, IRandomNoise* pRandom);
                // PKCS1_VER_21
                HRESULT EncryptWithKeyV21(BYTE* pOutput, const BYTE* pInput, size_t nSizeIn, IRandomNoise* pRandom, const BYTE* pLabel = nullptr, size_t nSizeLabel = 0);
 
                HRESULT DecryptWithKeyV15(BYTE* pOutput, size_t output_max_len, const BYTE* pInput, IRandomNoise* pRandom);
                HRESULT DecryptWithKeyV21(BYTE* pOutput, size_t output_max_len, const BYTE* pInput, IRandomNoise* pRandom, const BYTE* pLabel = nullptr, size_t nSizeLabel = 0);
 
                HRESULT MakeSignatureV15(BYTE* pSig, SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, IRandomNoise* pRandom) const;
                HRESULT MakeSignatureV21(BYTE* pSig, SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, IRandomNoise* pRandom) const;
 
        public:
                HRESULT VerifySignatureV15(SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, const BYTE* pSig) const;
                HRESULT VerifySignatureV21(SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, const BYTE* pSig, SSL_Hash_TYPE mgf1_hash_id, int expected_salt_len) const;
 
        public:
                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 DecryptWithKey(BYTE* pOutput, size_t nSizeOut, const BYTE* pInput, size_t nSizeIn, IRandomNoise* pRandom);
                HRESULT EncryptWithKey(BYTE* pOutput, size_t nSizeOut, const BYTE* pInput, size_t nSizeIn, IRandomNoise* pRandom);
 
                bool UpdateReadPrivate();
 
                virtual HRESULT ReadPublicKey(cASNReader& r, cASNBuf* pAlgParams) override
                {
                        UNREFERENCED_PARAMETER(pAlgParams);
                        HRESULT hRes = cKeyRSA1::ReadPublicKey(r);
                        this->m_nSizeBlock = this->m_N.get_BinarySize();
                        return hRes;
                }
                virtual HRESULT WritePublicKey(cASNWriterRev& w) const override
                {
                        return cKeyRSA1::WritePublicKey(w);
                }
 
                HRESULT ReadPrivateKeyPVK(const BYTE* pKeyData, int nSize);
                virtual HRESULT ReadPrivateKey(cASNReader& r, cASNBuf* pAlgParams) override;
                virtual HRESULT WritePrivateKey(cASNWriterRev& w) const override;
 
                HRESULT GenerateKeys(BIT_ENUM_t nBits, UINT nExpoMax, IRandomNoise* pRandom);
 
                UNITTEST_FRIEND(cKeyRSA);
        };
 
        class GRAYLIB_LINK cKeyTypeRSA : public cKeyTypeDef
        {
        public:
                cKeyTypeRSA() noexcept
                        : cKeyTypeDef(SSL_Key_RSA, "RSA")
                {
                }
                virtual bool HasKeyType(SSL_Key_TYPE eKeyType) const noexcept override
                {
                        // Allow signing with SSL_Key_RSASSA_PSS
                        return eKeyType == SSL_Key_RSA || eKeyType == SSL_Key_RSASSA_PSS ;
                }
                virtual cKeyBase* AllocKey(void) const override
                {
                        return new cKeyRSA();
                }
        };
}
 
#endif // _INC_cKeyRSA_H