HMAC.h

Go to the documentation of this file.

#pragma once
#include <aws/cal/hmac.h>
#include <aws/crt/Exports.h>
#include <aws/crt/Types.h>
 
struct aws_hmac;
namespace Aws
{
    namespace Crt
    {
        namespace Crypto
        {
            static const size_t SHA256_HMAC_DIGEST_SIZE = 32;
 
            bool AWS_CRT_CPP_API ComputeSHA256HMAC(
                Allocator *allocator,
                const ByteCursor &secret,
                const ByteCursor &input,
                ByteBuf &output,
                size_t truncateTo = 0) noexcept;
 
            bool AWS_CRT_CPP_API ComputeSHA256HMAC(
                const ByteCursor &secret,
                const ByteCursor &input,
                ByteBuf &output,
                size_t truncateTo = 0) noexcept;
            class AWS_CRT_CPP_API HMAC final
            {
              public:
                ~HMAC();
                HMAC(const HMAC &) = delete;
                HMAC &operator=(const HMAC &) = delete;
                HMAC(HMAC &&toMove);
                HMAC &operator=(HMAC &&toMove);
 
                inline operator bool() const noexcept { return m_good; }
 
                inline int LastError() const noexcept { return m_lastError; }
 
                static HMAC CreateSHA256HMAC(Allocator *allocator, const ByteCursor &secret) noexcept;
 
                static HMAC CreateSHA256HMAC(const ByteCursor &secret) noexcept;
 
                bool Update(const ByteCursor &toHMAC) noexcept;
 
                bool Digest(ByteBuf &output, size_t truncateTo = 0) noexcept;
 
                size_t DigestSize() const noexcept;
 
                bool ComputeOneShot(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
 
              private:
                HMAC(aws_hmac *hmac) noexcept;
                HMAC() = delete;
 
                aws_hmac *m_hmac;
                bool m_good;
                int m_lastError;
            };
 
            class AWS_CRT_CPP_API ByoHMAC
            {
              public:
                virtual ~ByoHMAC() = default;
 
                aws_hmac *SeatForCInterop(const std::shared_ptr<ByoHMAC> &selfRef);
 
              protected:
                ByoHMAC(size_t digestSize, const ByteCursor &secret, 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_hmac *hmac);
                static int s_Update(struct aws_hmac *hmac, const struct aws_byte_cursor *buf);
                static int s_Finalize(struct aws_hmac *hmac, struct aws_byte_buf *out);
 
                static aws_hmac_vtable s_Vtable;
                aws_hmac m_hmacValue;
                std::shared_ptr<ByoHMAC> m_selfReference;
            };
 
            using CreateHMACCallback =
                std::function<std::shared_ptr<ByoHMAC>(size_t digestSize, const ByteCursor &secret, Allocator *)>;
 
        } // namespace Crypto
    } // namespace Crt
} // namespace Aws