diff --git a/.cspell.json b/.cspell.json index 02572867d52..7c9b9daed82 100644 --- a/.cspell.json +++ b/.cspell.json @@ -1,79 +1,307 @@ { - "version": "0.1", - "language": "en-US,en-GB", - "words": [ - // C++ STL - "smatch", - // General - "SDK's", "sdks", "awssdk", "executables", "debuggable", "sdkutils", "presigning", "Presign", "queryxml", - "retryable", "payloadless", "Subclassing", "BASECLASS", "Millis", "hashcode", "LOGSTREAM", "timepoint", - "Bytebuf", "backbuf", "bitslen", "CLSCTX", "openrequest", "logtag", "stdext", "CPPRTTI", "backbuffer", - "Bodyless", "HTTPGET", "ratelimiter", "Ratelimiter", "STDMETHODCALLTYPE", "CANTSAVE", "OLECHAR", "DISPID", - "UNKNOWNNAME", "DISPPARAMS", "XMLHTTP", "comptr", "Metadataservice", "Streamfn", "HWAVEOUT", "matdesc", - "Presigner", "xindex", "errortype", "waveout", "WAVEOUTCAPSA", "ALLOWSYNC", "WAVEHDR", "MMSYSERR", - "WAVEFORMATEX", "Unprepare", "DDISABLE_IMDSV1", "SENDREQUEST", "threadpool", "stdlib", "ALLOC", "ISOE", - "isoe", - // AWS general - "Arns", "AMZN", "amzn", "Paulo", "Ningxia", "ISOB", "isob", "AWSXML", "IMDSV", "AWSSTL", - // AWS Signature - "SIGV", "AUTHV", - // CMake - "cmake", "DCMAKE", "AUTORUN", "DEPS", "STREQUAL", "RPATH", "STREQUAL", "DTARGET", "TOOLCHAIN", "DANDROID", - "DBUILD", "DDEBUG","DGIT", "DLEGACY","SYSROOT", "DSTATIC", "BINDIR", "LIBDIR", "INCLUDEDIR", "DHAS", - "PythonInterp", "DWAVE", "Winmm", "DPULSE", "pulseaudio", "MSVC", "NOTFOUND", "libpulse", "COREAUDIO", - "devel", "AUDIOTOOLBOX", "DCORE", "CONCAT", "DNON", "FULLPATCH", "setopt", "CURLOPT", "SSLCERT", - "CROSSCOMPILING", "nullptr", "DWORD", "lpsz", "commoncrypto", "COMMONCRYPTO", "endforeach", "pkgconfig", - "MGMT", "DENABLED", "DENFORCE", - // Compiler and linker - "Wpedantic", "Wextra", "Werror", "xldscope", "Wtype", "Wunused", "RTTI", "ffunction", "fdata", "fsanitize", - "pathconf", "unistd", "umask", "GNUCXX", "libasan", "SUNPRO", "gnustl", "libgnustl", "Wmissing", - // Android NDK - "JNIEXPORT", "jint", "JNICALL", "jobject", "jclass", "jmethod", "Ljava", "Logcat", - // XML parser - "QNXNTO", "TIXMLASSERT", "TIXML", "Untracked", "TINYXML", "tinyxml", "xmltest", "gccxmltest", "debugbreak", - "grinliz", "endverbatim", "xmlcstr", "callfopen", "overengineered", "callfopen", - // Json parser - "Jsonize", "CJSON", "cjson", "valuestring", "valueint", "valuedouble", "prebuffer", "subentities", "newitem", - "printbuffer", "newbuffer", "cinput", "Predeclare", "newchild", "crosswire", "oneline", - // IXMLHTTPRequest2 - "IXML", "IXMLHTTP", "HRESULT", "REFIID", "EXCEPINFO", "CLSID", "INPROC", "ONDATA", - // MSVC - "msvc", "MSFT", "LPDWORD", "DATAW", "mkgmtime", "vscprintf", "wtoi", "msxml", "runtimeobject", "winhttp", - "Wininet", "HINTERNET", "ADDREQ", "LPCSTR", "MAKELANGID", "SUBLANG", "WSADATA", "Initate", "ioctlsocket", - "dupenv", "USERPROFILE", "subblock", "LANGANDCODEPAGE", "CPPUNWIND", "keepalivetime", "keepaliveinterval", - // 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", - // EC2 - "IMDS", - // Eventstream - "EVENTSTREAM", "eventstream", "signedmsg", - // Cognito - "cognito", - // SSO - "sso", "SSO", "oidc", "OIDC", - // License and Notice - "SPDX", "grinninglizard", "Thomason", "Lepilleur", "Sidebotham", "Rublee", "Andrey", "Kamaev", - // Dependencies - "openssl", "libcurl", - // Aws common runtime libraries - "mqtt", - // Aws common runtime API - "Mtls", - // Opentelemetry - "Otel", "opentelemetry", "nostd", "OPTEL", "tparam","OTLP" - ], - "ignoreWords": [ - // variables defined in ConcurrentStreamBuf - "pbegin", "gbegin", - // functions defined in UUID - "hexify", - // enums defined in HttpResponse - "UNPROC", - // in DefaultRateLimiter - "renormalize", - // parameters defined in tinyxml2 - "uval" - ] + "version": "0.1", + "language": "en-US,en-GB", + "words": [ + // C++ STL + "smatch", + // General + "SDK's", + "sdks", + "awssdk", + "executables", + "debuggable", + "sdkutils", + "presigning", + "Presign", + "queryxml", + "retryable", + "payloadless", + "Subclassing", + "BASECLASS", + "Millis", + "hashcode", + "LOGSTREAM", + "timepoint", + "Bytebuf", + "backbuf", + "bitslen", + "CLSCTX", + "openrequest", + "logtag", + "stdext", + "CPPRTTI", + "backbuffer", + "Bodyless", + "HTTPGET", + "ratelimiter", + "Ratelimiter", + "STDMETHODCALLTYPE", + "CANTSAVE", + "OLECHAR", + "DISPID", + "UNKNOWNNAME", + "DISPPARAMS", + "XMLHTTP", + "comptr", + "Metadataservice", + "Streamfn", + "HWAVEOUT", + "matdesc", + "Presigner", + "xindex", + "errortype", + "waveout", + "WAVEOUTCAPSA", + "ALLOWSYNC", + "WAVEHDR", + "MMSYSERR", + "WAVEFORMATEX", + "Unprepare", + "DDISABLE_IMDSV1", + "SENDREQUEST", + "threadpool", + "stdlib", + "ALLOC", + "ISOE", + "isoe", + // AWS general + "Arns", + "AMZN", + "amzn", + "Paulo", + "Ningxia", + "ISOB", + "isob", + "AWSXML", + "IMDSV", + "AWSSTL", + // AWS Signature + "SIGV", + "AUTHV", + // CMake + "cmake", + "DCMAKE", + "AUTORUN", + "DEPS", + "STREQUAL", + "RPATH", + "STREQUAL", + "DTARGET", + "TOOLCHAIN", + "DANDROID", + "DBUILD", + "DDEBUG", + "DGIT", + "DLEGACY", + "SYSROOT", + "DSTATIC", + "BINDIR", + "LIBDIR", + "INCLUDEDIR", + "DHAS", + "PythonInterp", + "DWAVE", + "Winmm", + "DPULSE", + "pulseaudio", + "MSVC", + "NOTFOUND", + "libpulse", + "COREAUDIO", + "devel", + "AUDIOTOOLBOX", + "DCORE", + "CONCAT", + "DNON", + "FULLPATCH", + "setopt", + "CURLOPT", + "SSLCERT", + "CROSSCOMPILING", + "nullptr", + "DWORD", + "lpsz", + "commoncrypto", + "COMMONCRYPTO", + "endforeach", + "pkgconfig", + "MGMT", + "DENABLED", + "DENFORCE", + // Compiler and linker + "Wpedantic", + "Wextra", + "Werror", + "xldscope", + "Wtype", + "Wunused", + "RTTI", + "ffunction", + "fdata", + "fsanitize", + "pathconf", + "unistd", + "umask", + "GNUCXX", + "libasan", + "SUNPRO", + "gnustl", + "libgnustl", + "Wmissing", + // Android NDK + "JNIEXPORT", + "jint", + "JNICALL", + "jobject", + "jclass", + "jmethod", + "Ljava", + "Logcat", + // XML parser + "QNXNTO", + "TIXMLASSERT", + "TIXML", + "Untracked", + "TINYXML", + "tinyxml", + "xmltest", + "gccxmltest", + "debugbreak", + "grinliz", + "endverbatim", + "xmlcstr", + "callfopen", + "overengineered", + "callfopen", + // Json parser + "Jsonize", + "CJSON", + "cjson", + "valuestring", + "valueint", + "valuedouble", + "prebuffer", + "subentities", + "newitem", + "printbuffer", + "newbuffer", + "cinput", + "Predeclare", + "newchild", + "crosswire", + "oneline", + // IXMLHTTPRequest2 + "IXML", + "IXMLHTTP", + "HRESULT", + "REFIID", + "EXCEPINFO", + "CLSID", + "INPROC", + "ONDATA", + // MSVC + "msvc", + "MSFT", + "LPDWORD", + "DATAW", + "mkgmtime", + "vscprintf", + "wtoi", + "msxml", + "runtimeobject", + "winhttp", + "Wininet", + "HINTERNET", + "ADDREQ", + "LPCSTR", + "MAKELANGID", + "SUBLANG", + "WSADATA", + "Initate", + "ioctlsocket", + "dupenv", + "USERPROFILE", + "subblock", + "LANGANDCODEPAGE", + "CPPUNWIND", + "keepalivetime", + "keepaliveinterval", + // 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", + "NVME", + // EC2 + "IMDS", + // Eventstream + "EVENTSTREAM", + "eventstream", + "signedmsg", + // Cognito + "cognito", + // SSO + "sso", + "SSO", + "oidc", + "OIDC", + // License and Notice + "SPDX", + "grinninglizard", + "Thomason", + "Lepilleur", + "Sidebotham", + "Rublee", + "Andrey", + "Kamaev", + // Dependencies + "openssl", + "libcurl", + // Aws common runtime libraries + "mqtt", + // Aws common runtime API + "Mtls", + // Opentelemetry + "Otel", + "opentelemetry", + "nostd", + "OPTEL", + "tparam", + "OTLP" + ], + "ignoreWords": [ + // variables defined in ConcurrentStreamBuf + "pbegin", + "gbegin", + // functions defined in UUID + "hexify", + // enums defined in HttpResponse + "UNPROC", + // in DefaultRateLimiter + "renormalize", + // parameters defined in tinyxml2 + "uval" + ] } 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 new file mode 100644 index 00000000000..3d05b7a6d6f --- /dev/null +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC.h @@ -0,0 +1,91 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +#pragma once + +#include +#include +#include +#include + +namespace Aws { +namespace Utils { +namespace Crypto { +template ByteBuffer ConvertToBuffer(HashT value) { + static_assert(std::is_integral::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 +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(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 (stream.eof()) { + 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(streamBuffer), + Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE); + const auto bytesRead = static_cast(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; +}; +} // namespace Crypto +} // namespace Utils +} // namespace Aws 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 index 75fc30f0d56..4b6001cfcdf 100644 --- 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 @@ -22,7 +22,9 @@ #include +#include #include +#include 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>; + using CRC32CImpl = + CRCChecksum>; } // 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 new file mode 100644 index 00000000000..f20db8972af --- /dev/null +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/crypto/CRC64.h @@ -0,0 +1,35 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +#pragma once + +#include +#include +#include +#include + +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 m_hashImpl; +}; + +using CRC64Impl = CRCChecksum>; +} // namespace Crypto +} // namespace Utils +} // namespace Aws 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 index 12f610d4de1..6a770ae0b10 100644 --- 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 CreateCRC32CImplementation(); + /** + * Create a CRC32 Hash provider + */ + AWS_CORE_API std::shared_ptr CreateCRC64Implementation(); /** * Create a Sha1 Hash provider */ @@ -129,6 +133,11 @@ namespace Aws * Set the global factory for CRC32 Hash providers */ AWS_CORE_API void SetCRC32Factory(const std::shared_ptr& factory); + /** + * Set the global factory for CRC32 Hash providers + */ + AWS_CORE_API void + SetCRC64Factory(const std::shared_ptr &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 index c09806fbe0b..6a8e70d8603 100644 --- 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 #include #include -#include -#include -#include 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(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(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(streamBuffer), Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE); - auto bytesRead = stream.gcount(); - - if (bytesRead > 0) - { - runningCrc32 = aws_checksums_crc32(streamBuffer, static_cast(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(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(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(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(streamBuffer), Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE); - auto bytesRead = stream.gcount(); - - if (bytesRead > 0) - { - runningCrc32c = aws_checksums_crc32c(streamBuffer, static_cast(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(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 new file mode 100644 index 00000000000..5f29dbdd8a3 --- /dev/null +++ b/src/aws-cpp-sdk-core/source/utils/crypto/CRC64.cpp @@ -0,0 +1,38 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +#include +#include +#include + +using namespace Aws::Utils::Crypto; + +CRC64::CRC64() : m_hashImpl(CreateCRC64Implementation()) {} + +HashResult CRC64::Calculate(const Aws::String &str) { + if (m_hashImpl != nullptr) { + return m_hashImpl->Calculate(str); + } + return false; +} + +HashResult CRC64::Calculate(Aws::IStream &stream) { + if (m_hashImpl != nullptr) { + return m_hashImpl->Calculate(stream); + } + return false; +} + +void CRC64::Update(unsigned char *buffer, size_t bufferSize) { + if (m_hashImpl != nullptr) { + m_hashImpl->Update(buffer, bufferSize); + } +} + +HashResult CRC64::GetHash() { + if (m_hashImpl != nullptr) { + return m_hashImpl->GetHash(); + } + return false; +} 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 index 3207bcb928a..33f562c3608 100644 --- a/src/aws-cpp-sdk-core/source/utils/crypto/factory/Factories.cpp +++ b/src/aws-cpp-sdk-core/source/utils/crypto/factory/Factories.cpp @@ -3,11 +3,11 @@ * SPDX-License-Identifier: Apache-2.0. */ - +#include +#include #include -#include #include -#include +#include #ifndef NO_ENCRYPTION #include #include @@ -45,10 +45,14 @@ static std::shared_ptr& GetCRC32CFactory() return s_CRC32CFactory; } -static std::shared_ptr& GetSha1Factory() -{ - static std::shared_ptr s_Sha1Factory(nullptr); - return s_Sha1Factory; +static std::shared_ptr &GetCRC64Factory() { + static std::shared_ptr s_CRC64Factory(nullptr); + return s_CRC64Factory; +} + +static std::shared_ptr &GetSha1Factory() { + static std::shared_ptr s_Sha1Factory(nullptr); + return s_Sha1Factory; } static std::shared_ptr& GetSha256Factory() @@ -150,17 +154,22 @@ class DefaultCRC32CFactory : public HashFactory } }; -class DefaultSHA1Factory : public HashFactory -{ +class DefaultCRC64Factory : public HashFactory { public: - std::shared_ptr CreateImplementation() const override - { + std::shared_ptr CreateImplementation() const override { + return Aws::MakeShared(s_allocationTag); + } +}; + +class DefaultSHA1Factory : public HashFactory { +public: + std::shared_ptr CreateImplementation() const override { #ifndef NO_ENCRYPTION return Aws::MakeShared(s_allocationTag, Aws::Crt::Crypto::Hash::CreateSHA1()); #else return nullptr; #endif - } + } /** * Opportunity to make any static initialization calls you need to make. @@ -556,14 +565,15 @@ void Aws::Utils::Crypto::InitCrypto() GetCRC32CFactory() = Aws::MakeShared(s_allocationTag); } - if(GetSha1Factory()) - { - GetSha1Factory()->InitStaticState(); + if (!GetCRC64Factory()) { + GetCRC64Factory() = Aws::MakeShared(s_allocationTag); } - else - { - GetSha1Factory() = Aws::MakeShared(s_allocationTag); - GetSha1Factory()->InitStaticState(); + + if (GetSha1Factory()) { + GetSha1Factory()->InitStaticState(); + } else { + GetSha1Factory() = Aws::MakeShared(s_allocationTag); + GetSha1Factory()->InitStaticState(); } if(GetSha256Factory()) @@ -653,10 +663,13 @@ void Aws::Utils::Crypto::CleanupCrypto() GetCRC32CFactory() = nullptr; } - if(GetSha1Factory()) - { - GetSha1Factory()->CleanupStaticState(); - GetSha1Factory() = nullptr; + if (GetCRC64Factory()) { + GetCRC64Factory() = nullptr; + } + + if (GetSha1Factory()) { + GetSha1Factory()->CleanupStaticState(); + GetSha1Factory() = nullptr; } if(GetSha256Factory()) @@ -713,14 +726,19 @@ void Aws::Utils::Crypto::SetCRC32Factory(const std::shared_ptr& fac GetCRC32Factory() = factory; } -void Aws::Utils::Crypto::SetCRC32CFactory(const std::shared_ptr& factory) -{ - GetCRC32CFactory() = factory; +void Aws::Utils::Crypto::SetCRC64Factory( + const std::shared_ptr &factory) { + GetCRC64Factory() = factory; } -void Aws::Utils::Crypto::SetSha1Factory(const std::shared_ptr& factory) -{ - GetSha1Factory() = factory; +void Aws::Utils::Crypto::SetCRC32CFactory( + const std::shared_ptr &factory) { + GetCRC32CFactory() = factory; +} + +void Aws::Utils::Crypto::SetSha1Factory( + const std::shared_ptr &factory) { + GetSha1Factory() = factory; } void Aws::Utils::Crypto::SetSha256Factory(const std::shared_ptr& factory) @@ -773,13 +791,17 @@ std::shared_ptr Aws::Utils::Crypto::CreateCRC32CImplementation() return GetCRC32CFactory()->CreateImplementation(); } +std::shared_ptr Aws::Utils::Crypto::CreateCRC64Implementation() { + return GetCRC64Factory()->CreateImplementation(); +} + std::shared_ptr Aws::Utils::Crypto::CreateSha1Implementation() { - return GetSha1Factory()->CreateImplementation(); + return GetSha1Factory()->CreateImplementation(); } std::shared_ptr Aws::Utils::Crypto::CreateSha256Implementation() { - return GetSha256Factory()->CreateImplementation(); + return GetSha256Factory()->CreateImplementation(); } std::shared_ptr Aws::Utils::Crypto::CreateSha256HMACImplementation() diff --git a/tests/aws-cpp-sdk-core-tests/utils/crypto/HashTest.cpp b/tests/aws-cpp-sdk-core-tests/utils/crypto/HashTest.cpp index 0c5789e7abd..236c134814a 100644 --- a/tests/aws-cpp-sdk-core-tests/utils/crypto/HashTest.cpp +++ b/tests/aws-cpp-sdk-core-tests/utils/crypto/HashTest.cpp @@ -6,11 +6,12 @@ #include #include -#include -#include -#include -#include #include +#include +#include +#include +#include +#include #include @@ -118,3 +119,24 @@ TEST_F(HashUpdateTest, TestCRC32CUpdate) Aws::String hexHash = HashingUtils::HexEncode(digest); ASSERT_STREQ("fb5b991d", hexHash.c_str()); } + +TEST_F(HashUpdateTest, TestCRC64Update) { + Crypto::CRC64 hash; + + unsigned char buffer[Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE] = {}; + memset(buffer, 0, Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE); + + for (long int remainingBufferSize = 26214400; remainingBufferSize > 0;) { + size_t bufferSize = (std::min)( + remainingBufferSize, + static_cast(Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE)); + hash.Update(buffer, bufferSize); + remainingBufferSize -= static_cast(bufferSize); + } + + ByteBuffer digest = hash.GetHash().GetResult(); + ASSERT_EQ(8uL, digest.GetLength()); + + Aws::String hexHash = HashingUtils::HexEncode(digest); + ASSERT_STREQ("5b6f5045463ca45e", hexHash.c_str()); +}