cKeyWrap.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cKeyWrap_H
#define _INC_cKeyWrap_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cKeyBase.h"
#include "cKeyTypeDef.h"
#include "cKeyRSA.h"
#include "cKeyECPPair.h"
#include "cKeyECDSA.h"
 
#include "../File/cASNWriterRev.h"
#include "../Hash/cHashWrap.h"
#include "../SSL/SSLTypes.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cKeyWrap
        {
 
        public:
                const cKeyTypeDef* m_pKeyTypeDef;       
                cRefPtr<cKeyBase> m_pKeyBase;           
 
                static const char* k_pszPEM_RSAPK;      
                static const char* k_pszPEM_EC;         
                static const char* k_pszPEM_PK;         
                static const char* k_pszPEM_EPK;        
                static const char* k_pszPEM_Pub;        
 
        private:
                static HRESULT ReadAlgorithmIdentifier(cASNReader& r, SSL_Key_TYPE& eKeyType, OUT cASNBuf& params);
 
                HRESULT ReadPrivateKeyPkcs8Enc(const cMemBlock& key, const cMemBlock& password);
                HRESULT ReadPrivateKeyPkcs8(const cMemBlock& key);
                HRESULT ReadPrivateKeyPVK(const cMemBlock& key, const cMemBlock& password);
 
        public:
                cKeyWrap()
                        : m_pKeyTypeDef(nullptr)
                {
                }
                ~cKeyWrap()
                {
                        SetZeroKey();
                }
 
                bool isZeroKey() const
                {
                        return get_KeyType() == SSL_Key_NONE;
                }
                void SetZeroKey();
 
                static inline bool GetHashSize(SSL_Hash_TYPE eHashType, size_t* pnHashSize)
                {
                        if (*pnHashSize != 0)
                                return true;
                        const cHashTypeDef* pHashType = cHashTypeMgr::I().GetHashType(eHashType);
                        if (pHashType == nullptr)
                                return false;
                        *pnHashSize = pHashType->get_HashSize();
                        return true;
                }
 
                SSL_SIG_TYPE get_SSLSIGType() const;
                static SSL_Key_TYPE GetKeyTypeFromSSLSIG(SSL_SIG_TYPE sig);
 
                HRESULT InitKeyType(SSL_Key_TYPE eKeyType);
 
                cKeyECPPair* get_ECPPair() const;
 
                const char* get_KeyTypeName() const
                {
                        if ( this->m_pKeyTypeDef == nullptr)
                                return("invalid PK");
                        return(this->m_pKeyTypeDef->m_pszName);
                }
 
                size_t get_KeySize() const
                {
                        if ( this->m_pKeyBase == nullptr)
                                return 0;
                        return this->m_pKeyBase->get_KeySize();
                }
 
                bool HasKeyType(SSL_Key_TYPE eKeyType) const noexcept
                {
                        // null or NONE context can't do anything
                        if (this->m_pKeyTypeDef == nullptr)
                                return false;
                        return this->m_pKeyTypeDef->HasKeyType(eKeyType);
                }
 
                SSL_Key_TYPE get_KeyType() const
                {
                        if ( this->m_pKeyTypeDef == nullptr)
                                return SSL_Key_NONE;
                        return this->m_pKeyTypeDef->m_eKeyType;
                }
 
                HRESULT GetKeyValues(cKeyBase::cValue* items) const
                {
 
                        if ( this->m_pKeyBase == nullptr)
                                return NTE_BAD_DATA;
                        return this->m_pKeyBase->GetKeyValues(items);
                }
 
                //
                HRESULT ReadPrivateKey(const cMemBlock& key, const cMemBlock& password);
 
                HRESULT ReadPublicKey(cASNReader& r);
 
                //
                HRESULT ReadPublicKey(const BYTE* pKey, size_t nSizeKey);
 
                HRESULT ReadPrivateKeyFile(const FILECHAR_t* pszFilePath, const char* pszPassword);
 
                HRESULT ReadPublicKeyFile(const FILECHAR_t* pszFilePath);
 
                HRESULT WritePrivateKey(cASNWriterRev& wr) const;
 
                HRESULT WritePublicKey2(cASNWriterRev& wr) const;
 
                HRESULT WritePublicPEM(char* pOut, StrLen_t size) const;        // NOT USED
 
                HRESULT WritePrivatePEM(char* pOut, StrLen_t size) const; // NOT USED
 
                HRESULT WritePublicKey(cASNWriterRev& w) const;
 
                HRESULT CheckPublicPrivatePair(const cKeyWrap* pKeyPrivate) const;
 
                //
                //
                //
                HRESULT VerifySignature(SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, const BYTE* pSig, size_t nSizeSig) const;
 
                HRESULT VerifySignatureExt(const cKeySigAlg& sigalg, const cKeyRSASignOptions* pSignOptions, const BYTE* pHash, size_t nSizeHash, const cMemBlock& signBuffer) const;
 
                //
                //
                //
                //
                HRESULT MakeSignature(BYTE* pSig, SSL_Hash_TYPE eHashType, const BYTE* pHash, size_t nSizeHash, IRandomNoise* pRandom) const;
 
 
                HRESULT DecryptWithKey(BYTE* pOut, size_t nSizeOut, const BYTE* pInp, size_t nSizeIn, IRandomNoise* pRandom);
 
 
                HRESULT EncryptWithKey(BYTE* pOut, size_t nSizeOut, const BYTE* pInp, size_t nSizeIn, IRandomNoise* pRandom);
        };
}
 
#endif // _INC_cKeyWrap_H