Hash.h

Go to the documentation of this file.

#pragma once
 
#include <aws/crt/Exports.h>
#include <aws/crt/Types.h>
 
#include <aws/cal/hash.h>
 
struct aws_hash;
namespace Aws
{
    namespace Crt
    {
        namespace Crypto
        {
            static const size_t SHA1_DIGEST_SIZE = AWS_SHA1_LEN;
            static const size_t SHA256_DIGEST_SIZE = AWS_SHA256_LEN;
            static const size_t MD5_DIGEST_SIZE = AWS_MD5_LEN;
 
            bool AWS_CRT_CPP_API ComputeSHA256(
                Allocator *allocator,
                const ByteCursor &input,
                ByteBuf &output,
                size_t truncateTo = 0) noexcept;
 
            bool AWS_CRT_CPP_API
                ComputeSHA256(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
 
            bool AWS_CRT_CPP_API ComputeMD5(
                Allocator *allocator,
                const ByteCursor &input,
                ByteBuf &output,
                size_t truncateTo = 0) noexcept;
 
            bool AWS_CRT_CPP_API ComputeMD5(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
 
            bool AWS_CRT_CPP_API ComputeSHA1(
                Allocator *allocator,
                const ByteCursor &input,
                ByteBuf &output,
                size_t truncateTo = 0) noexcept;
 
            bool AWS_CRT_CPP_API ComputeSHA1(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
 
            class AWS_CRT_CPP_API Hash final
            {
              public:
                ~Hash();
                Hash(const Hash &) = delete;
                Hash &operator=(const Hash &) = delete;
                Hash(Hash &&toMove);
                Hash &operator=(Hash &&toMove);
 
                operator bool() const noexcept;
 
                inline int LastError() const noexcept { return m_lastError; }
 
                static Hash CreateSHA256(Allocator *allocator = ApiAllocator()) noexcept;
 
                static Hash CreateSHA1(Allocator *allocator = ApiAllocator()) noexcept;
 
                static Hash CreateMD5(Allocator *allocator = ApiAllocator()) noexcept;
 
                bool Update(const ByteCursor &toHash) noexcept;
 
                bool Digest(ByteBuf &output, size_t truncateTo = 0) noexcept;
 
                bool ComputeOneShot(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
 
                size_t DigestSize() const noexcept;
 
              private:
                Hash(aws_hash *hash) noexcept;
                Hash() = delete;
 
                aws_hash *m_hash;
                int m_lastError;
            };
 
            class AWS_CRT_CPP_API ByoHash
            {
              public:
                virtual ~ByoHash();
 
                aws_hash *SeatForCInterop(const std::shared_ptr<ByoHash> &selfRef);
 
              protected:
                ByoHash(size_t digestSize, Allocator *allocator = ApiAllocator());
 
                virtual bool UpdateInternal(const ByteCursor &toHash) noexcept = 0;
 
                virtual bool DigestInternal(ByteBuf &output, size_t truncateTo = 0) noexcept = 0;
 
              private:
                static void s_Destroy(struct aws_hash *hash);
                static int s_Update(struct aws_hash *hash, const struct aws_byte_cursor *buf);
                static int s_Finalize(struct aws_hash *hash, struct aws_byte_buf *out);
 
                static aws_hash_vtable s_Vtable;
                aws_hash m_hashValue;
                std::shared_ptr<ByoHash> m_selfReference;
            };
 
            using CreateHashCallback = std::function<std::shared_ptr<ByoHash>(size_t digestSize, Allocator *)>;
 
        } // namespace Crypto
    } // namespace Crt
} // namespace Aws