CryptoImpl.h

Go to the documentation of this file.

 
#pragma once
 
#include <aws/core/utils/crypto/Hash.h>
#include <aws/core/utils/crypto/HMAC.h>
#include <aws/core/utils/crypto/SecureRandom.h>
#include <aws/core/utils/crypto/Cipher.h>
#include <CommonCrypto/CommonDigest.h>
 
#if defined(__MAC_OS_X_VERSION_MAX_ALLOWED)
#if defined(__MAC_10_13) && (__MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_10_13)
#define MAC_13_AVAILABLE  1
#elif defined(__MAC_10_14_4) && (__MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_10_14_4)
#define MAC_14_4_AVAILABLE  1
#endif
#endif
 
struct _CCCryptor;
 
namespace Aws
{
    namespace Utils
    {
        namespace Crypto
        {
            class SecureRandomBytes_CommonCrypto : public SecureRandomBytes
            {
             public:
                SecureRandomBytes_CommonCrypto();
                ~SecureRandomBytes_CommonCrypto();
                void GetBytes(unsigned char* buffer, size_t bufferSize) override;
 
            private:
                FILE* fp;
            };
 
 
            class MD5CommonCryptoImpl : public Hash
            {
            public:
 
                MD5CommonCryptoImpl();
                virtual ~MD5CommonCryptoImpl() {}
 
                virtual HashResult Calculate(const Aws::String& str) override;
 
                virtual HashResult Calculate(Aws::IStream& stream) override;
 
                virtual void Update(unsigned char* buffer, size_t bufferSize) override;
 
                virtual HashResult GetHash() override;
 
            private:
// AWS_SUPPRESS_DEPRECATION(
                CC_MD5_CTX m_ctx;
                // )
            };
 
            class Sha1CommonCryptoImpl : public Hash
            {
            public:
 
                Sha1CommonCryptoImpl();
                virtual ~Sha1CommonCryptoImpl() {}
 
                virtual HashResult Calculate(const Aws::String& str) override;
 
                virtual HashResult Calculate(Aws::IStream& stream) override;
 
                virtual void Update(unsigned char* buffer, size_t bufferSize) override;
 
                virtual HashResult GetHash() override;
 
            private:
                CC_SHA1_CTX m_ctx;
            };
 
            class Sha256CommonCryptoImpl : public Hash
            {
            public:
 
                Sha256CommonCryptoImpl();
                virtual ~Sha256CommonCryptoImpl() {}
 
                virtual HashResult Calculate(const Aws::String& str) override;
 
                virtual HashResult Calculate(Aws::IStream& stream) override;
 
                virtual void Update(unsigned char* buffer, size_t bufferSize) override;
 
                virtual HashResult GetHash() override;
 
            private:
                CC_SHA256_CTX m_ctx;
            };
 
            class Sha256HMACCommonCryptoImpl : public HMAC
            {
            public:
 
                Sha256HMACCommonCryptoImpl() {}
                virtual ~Sha256HMACCommonCryptoImpl() {}
 
                virtual HashResult Calculate(const ByteBuffer& toSign, const ByteBuffer& secret) override;
            };
 
            class CommonCryptoCipher : public SymmetricCipher
            {
            public:
                CommonCryptoCipher(const CryptoBuffer& key, size_t ivSize, bool ctrMode = false);
 
                CommonCryptoCipher(CryptoBuffer&& key, CryptoBuffer&& initializationVector,
                              CryptoBuffer&& tag = CryptoBuffer(0));
 
                CommonCryptoCipher(const CryptoBuffer& key, const CryptoBuffer& initializationVector,
                              const CryptoBuffer& tag = CryptoBuffer(0));
 
                CommonCryptoCipher(const CommonCryptoCipher& other) = delete;
 
                CommonCryptoCipher& operator=(const CommonCryptoCipher& other) = delete;
 
                CommonCryptoCipher(CommonCryptoCipher&& toMove);
 
                CommonCryptoCipher& operator=(CommonCryptoCipher&& toMove) = default;
 
 
                virtual ~CommonCryptoCipher();
 
                CryptoBuffer EncryptBuffer(const CryptoBuffer& unEncryptedData) override;
 
                CryptoBuffer FinalizeEncryption() override;
 
                CryptoBuffer DecryptBuffer(const CryptoBuffer& encryptedData) override;
 
                CryptoBuffer FinalizeDecryption() override;
 
                void Reset() override;
 
            protected:
                virtual size_t GetBlockSizeBytes() const = 0;
 
                virtual size_t GetKeyLengthBits() const = 0;
 
                bool CheckKeyAndIVLength(size_t expectedKeyLength, size_t expectedIVLength);
 
                _CCCryptor* m_encryptorHandle;
                _CCCryptor* m_decryptorHandle;
 
            private:
                void Init();
            };
 
            class AES_CBC_Cipher_CommonCrypto : public CommonCryptoCipher
            {
            public:
                AES_CBC_Cipher_CommonCrypto(const CryptoBuffer& key);
 
                AES_CBC_Cipher_CommonCrypto(CryptoBuffer&& key, CryptoBuffer&& initializationVector);
 
                AES_CBC_Cipher_CommonCrypto(const CryptoBuffer& key, const CryptoBuffer& initializationVector);
 
                AES_CBC_Cipher_CommonCrypto(const AES_CBC_Cipher_CommonCrypto& other) = delete;
 
                AES_CBC_Cipher_CommonCrypto& operator=(const AES_CBC_Cipher_CommonCrypto& other) = delete;
 
                AES_CBC_Cipher_CommonCrypto(AES_CBC_Cipher_CommonCrypto&& toMove) = default;
 
                void Reset() override;
 
            protected:
                size_t GetBlockSizeBytes() const override;
 
                size_t GetKeyLengthBits() const override;
 
            private:
                void InitCipher();
 
                static size_t BlockSizeBytes;
                static size_t KeyLengthBits;
            };
 
            class AES_CTR_Cipher_CommonCrypto : public CommonCryptoCipher
            {
            public:
                AES_CTR_Cipher_CommonCrypto(const CryptoBuffer& key);
 
                AES_CTR_Cipher_CommonCrypto(CryptoBuffer&& key, CryptoBuffer&& initializationVector);
 
                AES_CTR_Cipher_CommonCrypto(const CryptoBuffer& key, const CryptoBuffer& initializationVector);
 
                AES_CTR_Cipher_CommonCrypto(const AES_CTR_Cipher_CommonCrypto& other) = delete;
 
                AES_CTR_Cipher_CommonCrypto& operator=(const AES_CTR_Cipher_CommonCrypto& other) = delete;
 
                AES_CTR_Cipher_CommonCrypto(AES_CTR_Cipher_CommonCrypto&& toMove) = default;
 
                void Reset() override;
 
            protected:
                size_t GetBlockSizeBytes() const override;
 
                size_t GetKeyLengthBits() const override;
 
            private:
                void InitCipher();
 
                static size_t BlockSizeBytes;
                static size_t KeyLengthBits;
            };
 
            class AES_GCM_Cipher_CommonCrypto : public CommonCryptoCipher
            {
            public:
                AES_GCM_Cipher_CommonCrypto(const CryptoBuffer& key);
 
                AES_GCM_Cipher_CommonCrypto(const CryptoBuffer& key, const CryptoBuffer* aad);
 
                AES_GCM_Cipher_CommonCrypto(CryptoBuffer&& key, CryptoBuffer&& initializationVector,
                    CryptoBuffer&& tag = CryptoBuffer(0), CryptoBuffer&& aad = CryptoBuffer(0));
 
                AES_GCM_Cipher_CommonCrypto(const CryptoBuffer& key, const CryptoBuffer& initializationVector,
                    const CryptoBuffer& tag = CryptoBuffer(), const CryptoBuffer& aad = CryptoBuffer());
 
                AES_GCM_Cipher_CommonCrypto(const AES_GCM_Cipher_CommonCrypto& other) = delete;
 
                AES_GCM_Cipher_CommonCrypto& operator=(const AES_GCM_Cipher_CommonCrypto& other) = delete;
 
                AES_GCM_Cipher_CommonCrypto(AES_GCM_Cipher_CommonCrypto&& toMove) = default;
 
                CryptoBuffer FinalizeEncryption() override;
                CryptoBuffer FinalizeDecryption() override;
 
                void Reset() override;
 
            protected:
                size_t GetBlockSizeBytes() const override;
 
                size_t GetKeyLengthBits() const override;
 
            private:
                void InitCipher();
 
                CryptoBuffer m_aad;
                static size_t BlockSizeBytes;
                static size_t KeyLengthBits;
                static size_t TagLengthBytes;
                static size_t IVLengthBytes;
            };
 
            class AES_KeyWrap_Cipher_CommonCrypto : public CommonCryptoCipher
            {
            public:
                AES_KeyWrap_Cipher_CommonCrypto(const CryptoBuffer& key);
 
                AES_KeyWrap_Cipher_CommonCrypto(const AES_KeyWrap_Cipher_CommonCrypto&) = delete;
 
                AES_KeyWrap_Cipher_CommonCrypto& operator=(const AES_KeyWrap_Cipher_CommonCrypto&) = delete;
 
                AES_KeyWrap_Cipher_CommonCrypto(AES_KeyWrap_Cipher_CommonCrypto&&) = default;
 
                CryptoBuffer EncryptBuffer(const CryptoBuffer& unEncryptedData) override;
 
                CryptoBuffer FinalizeEncryption() override;
 
                CryptoBuffer DecryptBuffer(const CryptoBuffer& encryptedData) override;
 
                CryptoBuffer FinalizeDecryption() override;
 
                void Reset() override;
 
            protected:
                inline size_t GetBlockSizeBytes() const override { return BlockSizeBytes; }
 
                inline size_t GetKeyLengthBits() const override { return KeyLengthBits; }
 
            private:
                static size_t BlockSizeBytes;
                static size_t KeyLengthBits;
 
                CryptoBuffer m_workingKeyBuffer;
            };
 
        } // namespace Crypto
    } // namespace Utils
} // namespace Aws