cCipherBase.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cCipherBase_H
#define _INC_cCipherBase_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/IUnknown.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cObject.h"
 
namespace GrayLib
{
        enum CipherAlgorithm_TYPE
        {
 
                CipherAlgorithm_NULL = 0,       // Just pass the data through.
                CipherAlgorithm_AES,
                CipherAlgorithm_Camellia,
                CipherAlgorithm_RC4,            // RC4, ARC4
                CipherAlgorithm_DES,
                CipherAlgorithm_Blowfish,
                CipherAlgorithm_GCM_AES,
                CipherAlgorithm_GCM_Camellia,
                CipherAlgorithm_CCM_AES,
                CipherAlgorithm_CCM_Camellia,
 
                CipherAlgorithm_QTY,
        };
 
        enum CipherVariable_TYPE
        {
                CipherVariable_NULL = 0,
                CipherVariable_IV_LEN = 0x01,    
                CipherVariable_KEY_LEN = 0x02,    
        };
 
        enum CipherKeySize_TYPE
        {
                CipherKeySize_NONE = 0, // Undefined key length
 
                // Key length, in bits (including parity), for DES keys
                CipherKeySize_DES = 8, // 64 bits
                CipherKeySize_64 = 8,    // 64 bits
 
                // Key length, in bits (including parity), for DES in two key EDE
                CipherKeySize_DES_EDE = 16,     // 128 bits = DES2
                CipherKeySize_128 = 16,
 
                // Key length, in bits (including parity), for DES in three-key EDE
                CipherKeySize_DES_EDE3 = 24,    // 192 bits = DES3
                CipherKeySize_192 = 24,
                CipherKeySize_256 = 32,         // 256 bits
 
                // Blowfish = 448 bits max.
        };
 
        enum CIPHER_BLOCK_TYPE
        {
 
                CIPHER_BLOCK_UNK = 0,   
 
                CIPHER_BLOCK_CBC = 1,           // like _WIN32 CRYPT_MODE_CBC
 
                CIPHER_BLOCK_ECB = 2,           // like _WIN32 CRYPT_MODE_ECB
 
                CIPHER_BLOCK_OFB = 3,           // like _WIN32 CRYPT_MODE_OFB
 
                CIPHER_BLOCK_CFB = 4,   // (default) like _WIN32 CRYPT_MODE_CFB
 
                CIPHER_BLOCK_CTR = 5,   // Counter. // CTS = Ciphertext stealing mode ? 
 
                // Special Counter modes. Not true modes.
                CIPHER_BLOCK_GCM,       // Galois/Counter mode for 128-bit block ciphers. AES or Camellia
                CIPHER_BLOCK_CCM,       // Counter with CBC-MAC (CCM) for 128-bit block ciphers. AES or Camellia
        };
 
        MIDL_INTERFACE("0C3E2E71-B93C-11d2-AAD0-006007348453") ICipherBase
        {
 
                IGNORE_WARN_INTERFACE(ICipherBase);
                virtual size_t get_BlockAlignSize() const = 0;
                virtual HRESULT Cipher(BYTE* pOutput, const BYTE* pInput, size_t nSizeBytes) = 0;
        };
 
        class GRAYLIB_LINK cCipherBase : public CObject, public ICipherBase // for cObjectFactory.
        {
 
        protected:
                bool m_bEncodeMode;                                     
                CIPHER_BLOCK_TYPE m_eBlockMode;         
 
        public:
                cCipherBase(bool bEncodeMode = true, CIPHER_BLOCK_TYPE eBlockMode = CIPHER_BLOCK_UNK) noexcept
                        : m_bEncodeMode(bEncodeMode)
                        , m_eBlockMode(eBlockMode)
                {
                }
                virtual ~cCipherBase()
                {
                }
 
                void put_EncodeMode(bool bEncodeMode) noexcept
                {
                        m_bEncodeMode = bEncodeMode;
                }
                bool get_EncodeMode() const noexcept
                {
                        return m_bEncodeMode;
                }
 
                void put_BlockMode(CIPHER_BLOCK_TYPE eBlockMode) noexcept
                {
                        m_eBlockMode = eBlockMode;
                }
 
                virtual size_t get_BlockAlignSize() const override
                {
                        return 1;
                }
 
                virtual HRESULT SetCipherKey(const void* pKeyData = nullptr, size_t nKeySize = 0)
                {
                        UNREFERENCED_PARAMETER(pKeyData);
                        UNREFERENCED_PARAMETER(nKeySize);
                        return S_OK;
                }
 
                virtual HRESULT CipherModeECB(BYTE* pOutput, const BYTE* pInput)
                {
                        UNREFERENCED_PARAMETER(pOutput);
                        UNREFERENCED_PARAMETER(pInput);
                        return E_NOTIMPL;
                }
                virtual HRESULT CipherModeCBC(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE* pIV)
                {
                        UNREFERENCED_PARAMETER(pOutput);
                        UNREFERENCED_PARAMETER(pInput);
                        UNREFERENCED_PARAMETER(nSize);
                        UNREFERENCED_PARAMETER(pIV);
                        return E_NOTIMPL;
                }
                virtual HRESULT CipherModeCFB(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE* pIV, size_t* pIVOffset)
                {
                        UNREFERENCED_PARAMETER(pOutput);
                        UNREFERENCED_PARAMETER(pInput);
                        UNREFERENCED_PARAMETER(nSize);
                        UNREFERENCED_PARAMETER(pIV);
                        UNREFERENCED_PARAMETER(pIVOffset);
                        return E_NOTIMPL;
                }
                virtual HRESULT CipherModeCTR(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE* pNonceCounter, size_t* pNCOffset, BYTE* pStreamBlock)
                {
                        UNREFERENCED_PARAMETER(pOutput);
                        UNREFERENCED_PARAMETER(pInput);
                        UNREFERENCED_PARAMETER(nSize);
                        UNREFERENCED_PARAMETER(pNonceCounter);
                        UNREFERENCED_PARAMETER(pNCOffset);
                        UNREFERENCED_PARAMETER(pStreamBlock);
                        return E_NOTIMPL;
                }
 
                virtual HRESULT Cipher(BYTE* pOutput, const BYTE* pInput, size_t nSize) override
                {
                        ::memcpy(pOutput, pInput, nSize);
                        return (HRESULT)nSize;
                }
 
                static size_t GRAYCALL CopyFillX(void* pOutput, size_t nOutSize, const void* pInput, size_t nInputSize);
        };
 
        class GRAYLIB_LINK cCipherBlockBase : public cCipherBase
        {
 
        public:
                CipherAlgorithm_TYPE m_eCipherAlgorithm;        
                cNewPtr<cCipherBase> m_pCipherBase;                     
 
        public:
                cCipherBlockBase(bool bEncodeMode, CipherAlgorithm_TYPE eCipherAlgorithm) noexcept
                        : cCipherBase(bEncodeMode)
                        , m_eCipherAlgorithm(eCipherAlgorithm)
                {
                }
 
                virtual HRESULT AuthEncrypt(BYTE* pOutput, const BYTE* pInput, size_t nSize,
                        const BYTE* pIV, size_t nSizeIV,
                        const BYTE* pAdd, size_t nSizeAdd,
                        BYTE* pTag, size_t nSizeTag) = 0;
 
                virtual HRESULT AuthDecrypt(BYTE* pOutput, const BYTE* pInput, size_t nSize,
                        const BYTE* pIV, size_t nSizeIV,
                        const BYTE* pAdd, size_t nSizeAdd,
                        const BYTE* pTag, size_t nSizeTag) = 0;
        };
 
        class GRAYLIB_LINK cCipherNone : public cCipherBase
        {
 
        public:
                size_t m_nBlockAlignSize;       
 
        public:
                cCipherNone(bool bEncodeMode = true, size_t nBlockAlignSize = 1) noexcept
                        : cCipherBase(bEncodeMode)
                        , m_nBlockAlignSize(nBlockAlignSize)
                {
                }
 
                virtual HRESULT SetCipherKey(const void* pKeyData = nullptr, size_t nKeySize = 0) override
                {
                        UNREFERENCED_PARAMETER(pKeyData);
                        UNREFERENCED_PARAMETER(nKeySize);
                        return S_OK;
                }
 
                virtual size_t get_BlockAlignSize() const override
                {
                        return m_nBlockAlignSize;
                }
 
                virtual HRESULT Cipher(BYTE* pOutput, const BYTE* pInput, size_t nSizeBytes) override
                {
                        if (m_nBlockAlignSize > 1)
                        {
                                nSizeBytes -= nSizeBytes % m_nBlockAlignSize;
                        }
                        ::memcpy(pOutput, pInput, nSizeBytes);
                        return (HRESULT)nSizeBytes;     // all with m_nBlockAlignSize
                }
        };
};
 
#endif // _INC_cCipherBase_H