Merge branch 'main' into MqttTestRefactor

Bret Ambrose · Bret Ambrose · commit 076e7fcf5e73 · 2026-02-11T12:08:31.000-08:00
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-0.37.1
+0.37.2
diff --git a/crt/aws-checksums b/crt/aws-checksums
@@ -1 +1 @@
-Subproject commit 270b15acc1b2125340ec1c6dda6cc3c28ef0fa44
+Subproject commit c412c636091501c2cd544d23664c8d14999e9dcc
diff --git a/include/aws/crt/Api.h b/include/aws/crt/Api.h
@@ -93,6 +93,12 @@ namespace Aws
              */
             void SetBYOCryptoNewSHA256Callback(Crypto::CreateHashCallback &&callback);
 
+            /**
+             * BYO_CRYPTO: set callback for creating SHA256 hashes.
+             * If using BYO_CRYPTO, you must call this.
+             */
+            void SetBYOCryptoNewSHA512Callback(Crypto::CreateHashCallback &&callback);
+
             /**
              * BYO_CRYPTO: set callback for creating SHA1 hashes.
              * If using BYO_CRYPTO, you must call this.
@@ -105,6 +111,12 @@ namespace Aws
              */
             void SetBYOCryptoNewSHA256HMACCallback(Crypto::CreateHMACCallback &&callback);
 
+            /**
+             * BYO_CRYPTO: set callback for creating Streaming SHA512 HMAC objects.
+             * If using BYO_CRYPTO, you must call this.
+             */
+            void SetBYOCryptoNewSHA512HMACCallback(Crypto::CreateHMACCallback &&callback);
+
             /**
              * BYO_CRYPTO: set callback for creating a ClientTlsChannelHandler.
              * If using BYO_CRYPTO, you must call this prior to creating any client channels in the
diff --git a/include/aws/crt/checksum/XXHash.h b/include/aws/crt/checksum/XXHash.h
@@ -0,0 +1,94 @@
+#pragma once
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/crt/Exports.h>
+#include <aws/crt/Types.h>
+
+struct aws_xxhash;
+namespace Aws
+{
+    namespace Crt
+    {
+        namespace Checksum
+        {
+            /**
+             * Computes a XXHash64 Hash over input, and writes the digest to output.
+             * Returns true on success. If this function fails,
+             * Aws::Crt::LastError() will contain the error that occurred.
+             */
+            bool AWS_CRT_CPP_API ComputeXXHash64(const ByteCursor &input, ByteBuf &output, uint64_t seed = 0) noexcept;
+
+            /**
+             * Computes a XXHash3_64 Hash using the default allocator over input, and writes the digest to output.
+             * Returns true on success. If this function fails,
+             * Aws::Crt::LastError() will contain the error that occurred.
+             */
+            bool AWS_CRT_CPP_API
+                ComputeXXHash3_64(const ByteCursor &input, ByteBuf &output, uint64_t seed = 0) noexcept;
+
+            /**
+             * Computes a XXHash3_128 Hash using the default allocator over input, and writes the digest to output.
+             * Returns true on success. If this function fails,
+             * Aws::Crt::LastError() will contain the error that occurred.
+             */
+            bool AWS_CRT_CPP_API
+                ComputeXXHash3_128(const ByteCursor &input, ByteBuf &output, uint64_t seed = 0) noexcept;
+
+            /**
+             * Streaming Hash object. The typical use case is for computing the hash of an object that is too large to
+             * load into memory. You can call Update() multiple times as you load chunks of data into memory. When
+             * you're finished simply call Digest(). After Digest() is called, this object is no longer usable.
+             */
+            class AWS_CRT_CPP_API XXHash final
+            {
+              public:
+                XXHash(const XXHash &) = delete;
+                XXHash &operator=(const XXHash &) = delete;
+                XXHash(XXHash &&toMove) noexcept = default;
+                XXHash &operator=(XXHash &&toMove) noexcept = default;
+
+                /**
+                 * Returns the value of the last aws error encountered by operations on this instance.
+                 */
+                inline int LastError() const noexcept { return m_lastError; }
+
+                /**
+                 * Creates an instance of a Streaming XXHash64 Hash.
+                 */
+                static XXHash CreateXXHash64(uint64_t seed = 0, Allocator *allocator = ApiAllocator()) noexcept;
+
+                /**
+                 * Creates an instance of a Streaming XXHash3_64 Hash.
+                 */
+                static XXHash CreateXXHash3_64(uint64_t seed = 0, Allocator *allocator = ApiAllocator()) noexcept;
+
+                /**
+                 * Creates an instance of a Streaming XXHash3_128 Hash.
+                 */
+                static XXHash CreateXXHash3_128(uint64_t seed = 0, Allocator *allocator = ApiAllocator()) noexcept;
+
+                /**
+                 * Updates the running hash object with data in toHash. Returns true on success. Call
+                 * LastError() for the reason this call failed.
+                 */
+                bool Update(const ByteCursor &toHash) noexcept;
+
+                /**
+                 * Finishes the running hash operation and writes the digest into output.
+                 * Returns true on success. Call LastError() for the reason this
+                 * call failed.
+                 */
+                bool Digest(ByteBuf &output) noexcept;
+
+              private:
+                XXHash(aws_xxhash *hash) noexcept;
+                XXHash() = delete;
+
+                ScopedResource<struct aws_xxhash> m_hash;
+                int m_lastError;
+            };
+        } // namespace Checksum
+    } // namespace Crt
+} // namespace Aws
diff --git a/include/aws/crt/crypto/Hash.h b/include/aws/crt/crypto/Hash.h
@@ -17,6 +17,7 @@ namespace Aws
         {
             static const size_t SHA1_DIGEST_SIZE = AWS_SHA1_LEN;
             static const size_t SHA256_DIGEST_SIZE = AWS_SHA256_LEN;
+            static const size_t SHA512_DIGEST_SIZE = AWS_SHA512_LEN;
             static const size_t MD5_DIGEST_SIZE = AWS_MD5_LEN;
 
             /**
@@ -64,7 +65,7 @@ namespace Aws
              * Computes a SHA1 Hash over input, and writes the digest to output. If truncateTo is non-zero, the digest
              * will be truncated to the value of truncateTo. Returns true on success. If this function fails,
              * Aws::Crt::LastError() will contain the error that occurred. Unless you're using 'truncateTo',
-             * output should have a minimum capacity of MD5_DIGEST_SIZE.
+             * output should have a minimum capacity of SHA1_DIGEST_SIZE.
              */
             bool AWS_CRT_CPP_API ComputeSHA1(
                 Allocator *allocator,
@@ -80,6 +81,27 @@ namespace Aws
              */
             bool AWS_CRT_CPP_API ComputeSHA1(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
 
+            /**
+             * Computes a SHA512 Hash over input, and writes the digest to output. If truncateTo is non-zero, the digest
+             * will be truncated to the value of truncateTo. Returns true on success. If this function fails,
+             * Aws::Crt::LastError() will contain the error that occurred. Unless you're using 'truncateTo',
+             * output should have a minimum capacity of SHA512_DIGEST_SIZE.
+             */
+            bool AWS_CRT_CPP_API ComputeSHA512(
+                Allocator *allocator,
+                const ByteCursor &input,
+                ByteBuf &output,
+                size_t truncateTo = 0) noexcept;
+
+            /**
+             * Computes a SHA512 Hash using the default allocator over input, and writes the digest to output. If
+             * truncateTo is non-zero, the digest will be truncated to the value of truncateTo. Returns true on success.
+             * If this function fails, Aws::Crt::LastError() will contain the error that occurred. Unless you're using
+             * 'truncateTo', output should have a minimum capacity of SHA512_DIGEST_SIZE.
+             */
+            bool AWS_CRT_CPP_API
+                ComputeSHA512(const ByteCursor &input, ByteBuf &output, size_t truncateTo = 0) noexcept;
+
             /**
              * Streaming Hash object. The typical use case is for computing the hash of an object that is too large to
              * load into memory. You can call Update() multiple times as you load chunks of data into memory. When
@@ -114,6 +136,11 @@ namespace Aws
                  */
                 static Hash CreateSHA1(Allocator *allocator = ApiAllocator()) noexcept;
 
+                /**
+                 * Creates an instance of a Stream SHA512 Hash.
+                 */
+                static Hash CreateSHA512(Allocator *allocator = ApiAllocator()) noexcept;
+
                 /**
                  * Creates an instance of a Streaming MD5 Hash.
                  */
diff --git a/source/Api.cpp b/source/Api.cpp
@@ -24,6 +24,7 @@ namespace Aws
     {
         static Crypto::CreateHashCallback s_BYOCryptoNewMD5Callback;
         static Crypto::CreateHashCallback s_BYOCryptoNewSHA256Callback;
+        static Crypto::CreateHashCallback s_BYOCryptoNewSHA512Callback;
         static Crypto::CreateHashCallback s_BYOCryptoNewSHA1Callback;
         static Crypto::CreateHMACCallback s_BYOCryptoNewSHA256HMACCallback;
         static Io::NewClientTlsHandlerCallback s_BYOCryptoNewClientTlsHandlerCallback;
@@ -84,6 +85,7 @@ namespace Aws
 
             s_BYOCryptoNewMD5Callback = nullptr;
             s_BYOCryptoNewSHA256Callback = nullptr;
+            s_BYOCryptoNewSHA512Callback = nullptr;
             s_BYOCryptoNewSHA256HMACCallback = nullptr;
             s_BYOCryptoNewClientTlsHandlerCallback = nullptr;
             s_BYOCryptoNewTlsContextImplCallback = nullptr;
@@ -189,6 +191,31 @@ namespace Aws
             aws_set_sha256_new_fn(s_Sha256New);
         }
 
+        static struct aws_hash *s_Sha512New(struct aws_allocator *allocator)
+        {
+            if (!s_BYOCryptoNewSHA512Callback)
+            {
+                AWS_LOGF_ERROR(
+                    AWS_LS_IO_TLS,
+                    "Must call ApiHandle::SetBYOCryptoNewSHA512Callback() before SHA256 hash can be created");
+                aws_raise_error(AWS_ERROR_UNIMPLEMENTED);
+                return nullptr;
+            }
+
+            auto hash = s_BYOCryptoNewSHA512Callback(AWS_SHA512_LEN, allocator);
+            if (!hash)
+            {
+                return nullptr;
+            }
+            return hash->SeatForCInterop(hash);
+        }
+
+        void ApiHandle::SetBYOCryptoNewSHA512Callback(Crypto::CreateHashCallback &&callback)
+        {
+            s_BYOCryptoNewSHA512Callback = std::move(callback);
+            aws_set_sha512_new_fn(s_Sha512New);
+        }
+
         static struct aws_hash *s_Sha1New(struct aws_allocator *allocator)
         {
             if (!s_BYOCryptoNewSHA1Callback)
@@ -308,6 +335,12 @@ namespace Aws
                 AWS_LS_IO_TLS, "SetBYOCryptoNewSHA256Callback() has no effect unless compiled with BYO_CRYPTO");
         }
 
+        void ApiHandle::SetBYOCryptoNewSHA512Callback(Crypto::CreateHashCallback &&)
+        {
+            AWS_LOGF_WARN(
+                AWS_LS_IO_TLS, "SetBYOCryptoNewSHA512Callback() has no effect unless compiled with BYO_CRYPTO");
+        }
+
         void ApiHandle::SetBYOCryptoNewSHA1Callback(Crypto::CreateHashCallback &&)
         {
             AWS_LOGF_WARN(AWS_LS_IO_TLS, "SetBYOCryptoNewSHA1Callback() has no effect unless compiled with BYO_CRYPTO");
@@ -319,6 +352,12 @@ namespace Aws
                 AWS_LS_IO_TLS, "SetBYOCryptoNewSHA256HMACCallback() has no effect unless compiled with BYO_CRYPTO");
         }
 
+        void ApiHandle::SetBYOCryptoNewSHA512HMACCallback(Crypto::CreateHMACCallback &&)
+        {
+            AWS_LOGF_WARN(
+                AWS_LS_IO_TLS, "SetBYOCryptoNewSHA256HMACCallback() has no effect unless compiled with BYO_CRYPTO");
+        }
+
         void ApiHandle::SetBYOCryptoClientTlsCallback(Io::NewClientTlsHandlerCallback &&)
         {
             AWS_LOGF_WARN(
diff --git a/source/checksum/XXHash.cpp b/source/checksum/XXHash.cpp
@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/checksums/xxhash.h>
+#include <aws/crt/Api.h>
+#include <aws/crt/checksum/XXHash.h>
+
+namespace Aws
+{
+    namespace Crt
+    {
+        namespace Checksum
+        {
+            bool ComputeXXHash64(const ByteCursor &input, ByteBuf &output, uint64_t seed) noexcept
+            {
+                return aws_xxhash64_compute(seed, input, &output) == AWS_OP_SUCCESS;
+            }
+
+            bool ComputeXXHash3_64(const ByteCursor &input, ByteBuf &output, uint64_t seed) noexcept
+            {
+                return aws_xxhash3_64_compute(seed, input, &output) == AWS_OP_SUCCESS;
+            }
+
+            bool ComputeXXHash3_128(const ByteCursor &input, ByteBuf &output, uint64_t seed) noexcept
+            {
+                return aws_xxhash3_128_compute(seed, input, &output) == AWS_OP_SUCCESS;
+            }
+
+            XXHash::XXHash(aws_xxhash *hash) noexcept : m_hash(hash, aws_xxhash_destroy), m_lastError(0)
+            {
+                if (hash == nullptr)
+                {
+                    m_lastError = Crt::LastError();
+                }
+            }
+
+            XXHash XXHash::CreateXXHash64(uint64_t seed, Allocator *allocator) noexcept
+            {
+                return XXHash(aws_xxhash64_new(allocator, seed));
+            }
+
+            XXHash XXHash::CreateXXHash3_64(uint64_t seed, Allocator *allocator) noexcept
+            {
+                return XXHash(aws_xxhash3_64_new(allocator, seed));
+            }
+
+            XXHash XXHash::CreateXXHash3_128(uint64_t seed, Allocator *allocator) noexcept
+            {
+                return XXHash(aws_xxhash3_128_new(allocator, seed));
+            }
+
+            bool XXHash::Update(const ByteCursor &toHash) noexcept
+            {
+                if (AWS_OP_SUCCESS != aws_xxhash_update(m_hash.get(), toHash))
+                {
+                    m_lastError = aws_last_error();
+                    return false;
+                }
+                return true;
+            }
+
+            bool XXHash::Digest(ByteBuf &output) noexcept
+            {
+                if (aws_xxhash_finalize(m_hash.get(), &output) != AWS_OP_SUCCESS)
+                {
+                    m_lastError = aws_last_error();
+                    return false;
+                }
+                return true;
+            }
+        } // namespace Checksum
+    } // namespace Crt
+} // namespace Aws
diff --git a/source/crypto/Hash.cpp b/source/crypto/Hash.cpp
@@ -27,6 +27,21 @@ namespace Aws
                 return ComputeSHA256(ApiAllocator(), input, output, truncateTo);
             }
 
+            bool ComputeSHA512(
+                Allocator *allocator,
+                const ByteCursor &input,
+                ByteBuf &output,
+                size_t truncateTo) noexcept
+            {
+                auto hash = Hash::CreateSHA512(allocator);
+                return hash.ComputeOneShot(input, output, truncateTo);
+            }
+
+            bool ComputeSHA512(const ByteCursor &input, ByteBuf &output, size_t truncateTo) noexcept
+            {
+                return ComputeSHA512(ApiAllocator(), input, output, truncateTo);
+            }
+
             bool ComputeSHA1(Allocator *allocator, const ByteCursor &input, ByteBuf &output, size_t truncateTo) noexcept
             {
                 auto hash = Hash::CreateSHA1(allocator);
@@ -102,6 +117,11 @@ namespace Aws
                 return Hash(aws_sha1_new(allocator));
             }
 
+            Hash Hash::CreateSHA512(Allocator *allocator) noexcept
+            {
+                return Hash(aws_sha512_new(allocator));
+            }
+
             bool Hash::Update(const ByteCursor &toHash) noexcept
             {
                 if (!*this)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -63,6 +63,7 @@ add_test_case(JsonExplicitNull)
 add_test_case(JsonBoolTest)
 add_test_case(JsonMoveTest)
 add_test_case(SHA256ResourceSafety)
+add_test_case(SHA512ResourceSafety)
 add_test_case(MD5ResourceSafety)
 add_test_case(SHA1ResourceSafety)
 add_test_case(SHA256HMACResourceSafety)
@@ -320,6 +321,14 @@ if (NOT BYO_CRYPTO)
     add_test_case(HKDFPiping)
 endif()
 
+add_test_case(CRC32Piping)
+add_test_case(CRC32CPiping)
+add_test_case(CRC64NVMEPiping)
+
+add_test_case(XXHash64Piping)
+add_test_case(XXHash3_64Piping)
+add_test_case(XXHash3_128Piping)
+
 generate_cpp_test_driver(${TEST_BINARY_NAME})
 
 aws_add_sanitizers(${TEST_BINARY_NAME})
diff --git a/tests/HashTest.cpp b/tests/HashTest.cpp
diff --git a/tests/XXHashTest.cpp b/tests/XXHashTest.cpp
