Add support for CRC64, refactor CRC32

sbiscigl · sbiscigl · commit d0ba4a66c933 · 2024-11-05T09:05:11.000-05:00
diff --git a/.cspell.json b/.cspell.json
@@ -44,7 +44,7 @@
         // Crypto
         "decryptor", "encryptor", "NTSTATUS", "PBYTE", "PUCHAR", "noconf", "HAMC", "PBCRYPT", "BCRYPT", "libcrypto",
         "AWSLC", "CBCCTS", "tweaklen", "taglen", "blockcipher", "AESGCM", "compated", "outdata", "Decrypto", "GCMAAD",
-        "CEKGCM", "HMACRAII", "OSSL", "ossl", "ccrng", "KEYWRAP",
+        "CEKGCM", "HMACRAII", "OSSL", "ossl", "ccrng", "KEYWRAP", "NVME",
         // EC2
         "IMDS",
         // Eventstream
diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC.h b/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC.h
@@ -0,0 +1,101 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#pragma once
+
+#include <aws/core/utils/crypto/Hash.h>
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <type_traits>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Crypto
+        {
+            template <typename HashT>
+            ByteBuffer ConvertToBuffer(HashT value)
+            {
+                static_assert(std::is_integral<HashT>::value, "Must use integral type to convert to buffer");
+                Aws::Utils::ByteBuffer buffer(sizeof(HashT));
+                for (size_t i = 0; i < sizeof(HashT); ++i)
+                {
+                    size_t shiftSize = (sizeof(HashT) - 1) * 8 - i * 8;
+                    buffer[i] = (value >> shiftSize) & 0xFF;
+                }
+                return buffer;
+            }
+
+            template <typename RunningChecksumT,
+                      RunningChecksumT (*CRTChecksumFuncT)(Crt::ByteCursor, RunningChecksumT),
+                      ByteBuffer (*ByteBufferFuncT)(RunningChecksumT)>
+            class CRCChecksum : public Hash
+            {
+            public:
+                CRCChecksum() : m_runningChecksum{0}
+                {
+                }
+
+                ~CRCChecksum() override = default;
+
+                HashResult Calculate(const Aws::String& str) override
+                {
+                    Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(reinterpret_cast<const uint8_t*>(str.data()), str.size());
+                    m_runningChecksum = CRTChecksumFuncT(byteCursor, m_runningChecksum);
+                    return ByteBufferFuncT(m_runningChecksum);
+                };
+
+                HashResult Calculate(Aws::IStream& stream) override
+                {
+                    auto currentPos = stream.tellg();
+                    if (currentPos == std::ios::pos_type(-1))
+                    {
+                        currentPos = 0;
+                        stream.clear();
+                    }
+
+                    stream.seekg(0, Aws::IStream::beg);
+
+                    uint8_t streamBuffer[Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE];
+                    while (stream.good())
+                    {
+                        stream.read(reinterpret_cast<char*>(streamBuffer), Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE);
+                        const auto bytesRead = static_cast<size_t>(stream.gcount());
+
+                        if (bytesRead > 0)
+                        {
+                            Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(streamBuffer, bytesRead);
+                            m_runningChecksum = CRTChecksumFuncT(byteCursor, m_runningChecksum);
+                        }
+                    }
+
+                    if (stream.bad())
+                    {
+                        AWS_LOGSTREAM_ERROR("CRCChecksum", "Stream encountered an error while calculating CRC Checksum");
+                    }
+
+                    stream.clear();
+                    stream.seekg(currentPos, Aws::IStream::beg);
+
+                    return ByteBufferFuncT(m_runningChecksum);
+                };
+
+                void Update(unsigned char* buffer, size_t bufferSize) override
+                {
+                    Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(buffer, bufferSize);
+                    m_runningChecksum = CRTChecksumFuncT(byteCursor, m_runningChecksum);
+                };
+
+                HashResult GetHash() override
+                {
+                    return ByteBufferFuncT(m_runningChecksum);
+                };
+
+            private:
+                RunningChecksumT m_runningChecksum;
+            };
+        }
+    }
+}
diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC32.h b/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC32.h
@@ -23,6 +23,8 @@
 #include <aws/core/Core_EXPORTS.h>
 
 #include <aws/core/utils/crypto/Hash.h>
+#include <aws/core/utils/crypto/CRC.h>
+#include <aws/crt/checksum/CRC.h>
 
 namespace Aws
 {
@@ -103,44 +105,13 @@ namespace Aws
                 std::shared_ptr< Hash > m_hashImpl;
             };
 
-            class AWS_CORE_API CRC32Impl : public Hash
-            {
-            public:
-
-                CRC32Impl();
-                virtual ~CRC32Impl() {}
-
-                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:
-                int m_runningCrc32;
-            };
-
-            class AWS_CORE_API CRC32CImpl : public Hash
-            {
-            public:
-
-                CRC32CImpl();
-                virtual ~CRC32CImpl() {}
-
-                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:
-                int m_runningCrc32c;
-            };
+            using CRC32Impl = CRCChecksum<uint32_t,
+                Aws::Crt::Checksum::ComputeCRC32,
+                ConvertToBuffer<uint32_t>>;
 
+            using CRC32CImpl = CRCChecksum<uint32_t,
+                Aws::Crt::Checksum::ComputeCRC32C,
+                ConvertToBuffer<uint32_t>>;
         } // namespace Crypto
     } // namespace Utils
 } // namespace Aws
diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC64.h b/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC64.h
@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#pragma once
+
+#include <aws/core/Core_EXPORTS.h>
+#include <aws/core/utils/crypto/Hash.h>
+#include <aws/core/utils/crypto/CRC.h>
+#include <aws/crt/checksum/CRC.h>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Crypto
+        {
+            /**
+             * CRC64 hash implementation.
+             */
+            class AWS_CORE_API CRC64 : public Hash
+            {
+            public:
+                CRC64();
+                ~CRC64() override = default;
+                HashResult Calculate(const Aws::String& str) override;
+                HashResult Calculate(Aws::IStream& stream) override;
+                void Update(unsigned char* buffer, size_t bufferSize) override;
+                HashResult GetHash() override;
+
+            private:
+                std::shared_ptr<Hash> m_hashImpl;
+            };
+
+            using CRC64Impl = CRCChecksum<uint64_t,
+                Aws::Crt::Checksum::ComputeCRC64NVME,
+                ConvertToBuffer<uint64_t>>;
+        }
+    }
+}
diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/Factories.h b/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/Factories.h
@@ -51,6 +51,10 @@ namespace Aws
              * Create a CRC32C Hash provider
              */
             AWS_CORE_API std::shared_ptr<Hash> CreateCRC32CImplementation();
+            /**
+             * Create a CRC32 Hash provider
+             */
+            AWS_CORE_API std::shared_ptr<Hash> CreateCRC64Implementation();
             /**
              * Create a Sha1 Hash provider
              */
@@ -129,6 +133,10 @@ namespace Aws
              * Set the global factory for CRC32 Hash providers
              */
             AWS_CORE_API void SetCRC32Factory(const std::shared_ptr<HashFactory>& factory);
+            /**
+             * Set the global factory for CRC32 Hash providers
+             */
+            AWS_CORE_API void SetCRC64Factory(const std::shared_ptr<HashFactory>& factory);
             /**
              * Set the global factory for CRC32C Hash providers
              */
diff --git a/src/aws-cpp-sdk-core/source/utils/crypto/CRC32.cpp b/src/aws-cpp-sdk-core/source/utils/crypto/CRC32.cpp
@@ -7,22 +7,9 @@
 #include <aws/core/utils/crypto/CRC32.h>
 #include <aws/core/utils/Outcome.h>
 #include <aws/core/utils/crypto/Factories.h>
-#include <aws/crt/Types.h>
-#include <aws/checksums/crc.h>
-#include <aws/common/byte_buf.h>
 
 using namespace Aws::Utils::Crypto;
 
-static Aws::Utils::ByteBuffer ByteBufferFromInt32(uint32_t value)
-{
-    Aws::Utils::ByteBuffer buffer(4);
-    buffer[0] = (value >> 24) & 0xFF;
-    buffer[1] = (value >> 16) & 0xFF;
-    buffer[2] = (value >> 8) & 0xFF;
-    buffer[3] = value & 0xFF;
-    return buffer;
-}
-
 CRC32::CRC32() :
     m_hashImpl(CreateCRC32Implementation())
 {
@@ -81,138 +68,3 @@ HashResult CRC32C::GetHash()
 {
     return m_hashImpl->GetHash();
 }
-
-
-CRC32Impl::CRC32Impl() : m_runningCrc32(0) {}
-
-HashResult CRC32Impl::Calculate(const Aws::String& str)
-{
-    Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(reinterpret_cast<const uint8_t*>(str.data()), str.size());
-
-    uint32_t runningCrc32 = 0;
-    while (byteCursor.len > INT_MAX)
-    {
-        runningCrc32 = aws_checksums_crc32(byteCursor.ptr, INT_MAX, runningCrc32);
-        aws_byte_cursor_advance(&byteCursor, INT_MAX);
-    }
-    runningCrc32 = aws_checksums_crc32(byteCursor.ptr, static_cast<int>(byteCursor.len), runningCrc32);
-    const Aws::Utils::ByteBuffer& hash = ByteBufferFromInt32(runningCrc32);
-    return HashResult(std::move(hash));
-}
-
-HashResult CRC32Impl::Calculate(Aws::IStream& stream)
-{
-    uint32_t runningCrc32 = 0;
-
-    auto currentPos = stream.tellg();
-    if (currentPos == std::ios::pos_type(-1))
-    {
-        currentPos = 0;
-        stream.clear();
-    }
-
-    stream.seekg(0, stream.beg);
-
-    uint8_t streamBuffer[Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE];
-    while (stream.good())
-    {
-        stream.read(reinterpret_cast<char*>(streamBuffer), Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE);
-        auto bytesRead = stream.gcount();
-
-        if (bytesRead > 0)
-        {
-            runningCrc32 = aws_checksums_crc32(streamBuffer, static_cast<int>(bytesRead), runningCrc32);
-        }
-    }
-
-    stream.clear();
-    stream.seekg(currentPos, stream.beg);
-
-    const Aws::Utils::ByteBuffer& hash = ByteBufferFromInt32(runningCrc32);
-    return HashResult(std::move(hash));
-}
-
-void CRC32Impl::Update(unsigned char* buffer, size_t bufferSize)
-{
-    Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(buffer, bufferSize);
-
-    while (byteCursor.len > INT_MAX)
-    {
-        m_runningCrc32 = aws_checksums_crc32(byteCursor.ptr, INT_MAX, m_runningCrc32);
-        aws_byte_cursor_advance(&byteCursor, INT_MAX);
-    }
-    m_runningCrc32 = aws_checksums_crc32(byteCursor.ptr, static_cast<int>(byteCursor.len), m_runningCrc32);
-}
-
-HashResult CRC32Impl::GetHash()
-{
-    const Aws::Utils::ByteBuffer& hash = ByteBufferFromInt32(m_runningCrc32);
-    return HashResult(std::move(hash));
-}
-
-CRC32CImpl::CRC32CImpl() : m_runningCrc32c(0) {}
-
-HashResult CRC32CImpl::Calculate(const Aws::String& str)
-{
-    Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(reinterpret_cast<const uint8_t*>(str.data()), str.size());
-
-    uint32_t runningCrc32c = 0;
-    while (byteCursor.len > INT_MAX)
-    {
-        runningCrc32c = aws_checksums_crc32c(byteCursor.ptr, INT_MAX, runningCrc32c);
-        aws_byte_cursor_advance(&byteCursor, INT_MAX);
-    }
-    runningCrc32c = aws_checksums_crc32c(byteCursor.ptr, static_cast<int>(byteCursor.len), runningCrc32c);
-    const Aws::Utils::ByteBuffer& hash = ByteBufferFromInt32(runningCrc32c);
-    return HashResult(std::move(hash));
-}
-
-HashResult CRC32CImpl::Calculate(Aws::IStream& stream)
-{
-    uint32_t runningCrc32c = 0;
-
-    auto currentPos = stream.tellg();
-    if (currentPos == std::ios::pos_type(-1))
-    {
-        currentPos = 0;
-        stream.clear();
-    }
-
-    stream.seekg(0, stream.beg);
-
-    uint8_t streamBuffer[Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE];
-    while (stream.good())
-    {
-        stream.read(reinterpret_cast<char*>(streamBuffer), Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE);
-        auto bytesRead = stream.gcount();
-
-        if (bytesRead > 0)
-        {
-            runningCrc32c = aws_checksums_crc32c(streamBuffer, static_cast<int>(bytesRead), runningCrc32c);
-        }
-    }
-
-    stream.clear();
-    stream.seekg(currentPos, stream.beg);
-
-    const Aws::Utils::ByteBuffer& hash = ByteBufferFromInt32(runningCrc32c);
-    return HashResult(std::move(hash));
-}
-
-void CRC32CImpl::Update(unsigned char* buffer, size_t bufferSize)
-{
-    Aws::Crt::ByteCursor byteCursor = Aws::Crt::ByteCursorFromArray(buffer, bufferSize);
-
-    while (byteCursor.len > INT_MAX)
-    {
-        m_runningCrc32c = aws_checksums_crc32c(byteCursor.ptr, INT_MAX, m_runningCrc32c);
-        aws_byte_cursor_advance(&byteCursor, INT_MAX);
-    }
-    m_runningCrc32c = aws_checksums_crc32c(byteCursor.ptr, static_cast<int>(byteCursor.len), m_runningCrc32c);
-}
-
-HashResult CRC32CImpl::GetHash()
-{
-    const Aws::Utils::ByteBuffer& hash = ByteBufferFromInt32(m_runningCrc32c);
-    return HashResult(std::move(hash));
-}
diff --git a/src/aws-cpp-sdk-core/source/utils/crypto/CRC64.cpp b/src/aws-cpp-sdk-core/source/utils/crypto/CRC64.cpp
diff --git a/src/aws-cpp-sdk-core/source/utils/crypto/factory/Factories.cpp b/src/aws-cpp-sdk-core/source/utils/crypto/factory/Factories.cpp
diff --git a/tests/aws-cpp-sdk-core-tests/utils/crypto/HashTest.cpp b/tests/aws-cpp-sdk-core-tests/utils/crypto/HashTest.cpp
