swap base64 implementation to CRT

Author: sbiscigl

crt/aws-crt-cpp

@@ -57,11 +57,6 @@ namespace Aws
                 * Calculates the length of an encoded base64 string based on the buffer being encoded
                 */
                 static size_t CalculateBase64EncodedLength(const ByteBuffer& buffer);
-
-            private:
-                char m_mimeBase64EncodingTable[64];
-                uint8_t m_mimeBase64DecodingTable[256];
-
             };
 
         } // namespace Base64

src/aws-cpp-sdk-core/include/aws/core/utils/base64/Base64.h

@@ -3,146 +3,46 @@
  * SPDX-License-Identifier: Apache-2.0.
  */
 
+#include <aws/core/utils/UnreferencedParam.h>
 #include <aws/core/utils/base64/Base64.h>
-#include <cstring>
+#include <aws/crt/Types.h>
 
 using namespace Aws::Utils::Base64;
 
-static const uint8_t SENTINEL_VALUE = 255;
-static const char BASE64_ENCODING_TABLE_MIME[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+namespace Aws {
+namespace Utils {
+namespace Base64 {
 
-namespace Aws
-{
-namespace Utils
-{
-namespace Base64
-{
-
-Base64::Base64(const char *encodingTable)
-{
-    if(encodingTable == nullptr)
-    {
-        encodingTable = BASE64_ENCODING_TABLE_MIME;
-    }
-
-    size_t encodingTableLength = strlen(encodingTable);
-    if(encodingTableLength != 64)
-    {
-        encodingTable = BASE64_ENCODING_TABLE_MIME;
-        encodingTableLength = 64;
-    }
-
-    memcpy(m_mimeBase64EncodingTable, encodingTable, encodingTableLength);
-
-    memset((void *)m_mimeBase64DecodingTable, 0, 256);
-
-    for(uint32_t i = 0; i < encodingTableLength; ++i)
-    {
-        uint32_t index = static_cast<uint32_t>(m_mimeBase64EncodingTable[i]);
-        m_mimeBase64DecodingTable[index] = static_cast<uint8_t>(i);
-    }
-
-    m_mimeBase64DecodingTable[(uint32_t)'='] = SENTINEL_VALUE;
+namespace {
+Aws::Crt::ByteCursor AsCursor(const Aws::Utils::ByteBuffer& buffer) {
+  return Aws::Crt::ByteCursorFromArray(buffer.GetUnderlyingData(), buffer.GetLength());
 }
 
-Aws::String Base64::Encode(const Aws::Utils::ByteBuffer& buffer) const
-{
-    size_t bufferLength = buffer.GetLength();
-    size_t blockCount = (bufferLength + 2) / 3;
-    size_t remainderCount = (bufferLength % 3);
-
-    Aws::String outputString;
-    outputString.reserve(CalculateBase64EncodedLength(buffer));
-
-    for(size_t i = 0; i < bufferLength; i += 3 )
-    {
-        uint32_t block = buffer[ i ];
-
-        block <<= 8;
-        if (i + 1 < bufferLength)
-        {
-            block = block | buffer[ i + 1 ];
-        }
-
-        block <<= 8;
-        if (i + 2 < bufferLength)
-        {
-            block = block | buffer[ i + 2 ];
-        }
-
-        outputString.push_back(m_mimeBase64EncodingTable[(block >> 18) & 0x3F]);
-        outputString.push_back(m_mimeBase64EncodingTable[(block >> 12) & 0x3F]);
-        outputString.push_back(m_mimeBase64EncodingTable[(block >> 6) & 0x3F]);
-        outputString.push_back(m_mimeBase64EncodingTable[block & 0x3F]);
-    }
-
-    if(remainderCount > 0)
-    {
-        outputString[blockCount * 4 - 1] = '=';
-        if(remainderCount == 1)
-        {
-            outputString[blockCount * 4 - 2] = '=';
-        }
-    }
-
-    return outputString;
+Aws::Crt::ByteCursor AsCursor(const Aws::String& str) {
+  return Aws::Crt::ByteCursorFromArray(reinterpret_cast<const uint8_t*>(str.data()), str.length());
 }
+}  // namespace
 
-Aws::Utils::ByteBuffer Base64::Decode(const Aws::String& str) const
-{
-    size_t decodedLength = CalculateBase64DecodedLength(str);
-
-    Aws::Utils::ByteBuffer buffer(decodedLength);
-
-    const char* rawString = str.c_str();
-    size_t blockCount = str.length() / 4;
-    for(size_t i = 0; i < blockCount; ++i)
-    {
-        size_t stringIndex = i * 4;
+Base64::Base64(const char* encodingTable) { AWS_UNREFERENCED_PARAM(encodingTable); }
 
-        uint32_t value1 = m_mimeBase64DecodingTable[uint32_t(rawString[stringIndex])];
-        uint32_t value2 = m_mimeBase64DecodingTable[uint32_t(rawString[++stringIndex])];
-        uint32_t value3 = m_mimeBase64DecodingTable[uint32_t(rawString[++stringIndex])];
-        uint32_t value4 = m_mimeBase64DecodingTable[uint32_t(rawString[++stringIndex])];
-
-        size_t bufferIndex = i * 3;
-        buffer[bufferIndex] = static_cast<uint8_t>((value1 << 2) | ((value2 >> 4) & 0x03));
-        if(value3 != SENTINEL_VALUE)
-        {
-            buffer[++bufferIndex] = static_cast<uint8_t>(((value2 << 4) & 0xF0) | ((value3 >> 2) & 0x0F));
-            if(value4 != SENTINEL_VALUE)
-            {
-                buffer[++bufferIndex] = static_cast<uint8_t>((value3 & 0x03) << 6 | value4);
-            }
-        }
-    }
-
-    return buffer;
+Aws::String Base64::Encode(const Aws::Utils::ByteBuffer& buffer) const {
+  const auto encoded = Aws::Crt::Base64Encode(AsCursor(buffer));
+  return {encoded.data(), encoded.size()};
 }
 
-size_t Base64::CalculateBase64DecodedLength(const Aws::String& b64input)
-{
-    const size_t len = b64input.length();
-    if(len < 2)
-    {
-        return 0;
-    }
-
-    size_t padding = 0;
-
-    if (b64input[len - 1] == '=' && b64input[len - 2] == '=') //last two chars are =
-        padding = 2;
-    else if (b64input[len - 1] == '=') //last char is =
-        padding = 1;
+Aws::Utils::ByteBuffer Base64::Decode(const Aws::String& str) const {
+  const auto decoded = Aws::Crt::Base64Decode(AsCursor(str));
+  return {decoded.data(), decoded.size()};
+}
 
-    return (len * 3 / 4 - padding);
+size_t Base64::CalculateBase64EncodedLength(const Aws::Utils::ByteBuffer& buffer) {
+  return Aws::Crt::Base64EncodedLength(AsCursor(buffer));
 }
 
-size_t Base64::CalculateBase64EncodedLength(const Aws::Utils::ByteBuffer& buffer)
-{
-    return 4 * ((buffer.GetLength() + 2) / 3);
+size_t Base64::CalculateBase64DecodedLength(const Aws::String& b64input) {
+  return Aws::Crt::Base64DecodedLength(AsCursor(b64input));
 }
 
-} // namespace Base64
-} // namespace Utils
-} // namespace Aws
+}  // namespace Base64
+}  // namespace Utils
+}  // namespace Aws

src/aws-cpp-sdk-core/source/utils/base64/Base64.cpp

@@ -6,6 +6,7 @@
 #include <aws/testing/AwsCppSdkGTestSuite.h>
 
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/base64/Base64.h>
 #include <aws/core/utils/memory/stl/AWSStringStream.h>
 
 
@@ -68,6 +69,37 @@ TEST_F(HashingUtilsTest, TestBase64Decoding)
     ASSERT_EQ(ByteBuffer((unsigned char*) "foobar", 6), test7);
 }
 
+TEST_F(HashingUtilsTest, TestBase64DecodeRejectsMisplacedPadding)
+{
+    for (const auto* encoded : {"AAAA=", "AAAAA=", "AAAAAA=", "AB=D", "="})
+    {
+        const Aws::String input(encoded);
+        ASSERT_EQ(0u, HashingUtils::Base64Decode(input).GetLength()) << "input: " << encoded;
+    }
+}
+
+TEST_F(HashingUtilsTest, TestBase64DecodeRejectsNonAsciiBytes)
+{
+    for (int byte = 0x80; byte <= 0xFF; ++byte)
+    {
+        const char raw[] = {static_cast<char>(byte), 'A', 'A', 'A'};
+        const Aws::String input(raw, sizeof(raw));
+        ASSERT_EQ(0u, HashingUtils::Base64Decode(input).GetLength()) << "byte: " << byte;
+    }
+}
+
+TEST_F(HashingUtilsTest, TestBase64DecodedLengthNeverUnderAllocates)
+{
+    const Aws::Utils::Base64::Base64 base64;
+    for (const auto* encoded : {"", "X", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy",
+                                "AAAA=", "AAAAA=", "AB=D", "=", "====", "A===", "//++", "AA=="})
+    {
+        const Aws::String input(encoded);
+        ASSERT_LE(base64.Decode(input).GetLength(), Aws::Utils::Base64::Base64::CalculateBase64DecodedLength(input))
+            << "input: " << encoded;
+    }
+}
+
 TEST_F(HashingUtilsTest, TestHexEncodingDecoding)
 {
     unsigned char beforeHexEncoding[32] =