Fix base64 encode/decode and To/From Base64 string (#3082)

***NO_CI***

Author: josesimoes

src/CLR/CorLib/corlib_native_System_Convert.cpp

@@ -1,4 +1,4 @@
-//
+//
 // Copyright (c) .NET Foundation and Contributors
 // Portions Copyright (c) Microsoft Corporation. All rights reserved.
 // Portions Copyright (C) 2002-2019 Free Software Foundation, Inc. All rights reserved.
@@ -595,13 +595,13 @@ HRESULT Library_corlib_native_System_Convert::ToBase64String___STATIC__STRING__S
 #if (SUPPORT_ANY_BASE_CONVERSION == TRUE)
 
     size_t outputLength;
-    char *outArray = NULL;
+    unsigned char *outArray = NULL;
     char *outArrayWitLineBreak = NULL;
-    uint8_t *inArrayPointer = NULL;
-    int32_t lineBreakCount;
+    unsigned char *inArrayPointer = NULL;
+    size_t lineBreakCount;
     uint16_t offsetIndex = 0;
-    uint8_t count = 0;
-    uint16_t result;
+    size_t count = 0;
+    int result;
 
     CLR_RT_HeapBlock_Array *inArray = stack.Arg0().DereferenceArray();
     size_t offset = (size_t)stack.Arg1().NumericByRef().s4;
@@ -610,14 +610,14 @@ HRESULT Library_corlib_native_System_Convert::ToBase64String___STATIC__STRING__S
 
     FAULT_ON_NULL_ARG(inArray);
 
-    inArrayPointer = (uint8_t *)inArray->GetFirstElement();
+    inArrayPointer = inArray->GetFirstElement();
     inArrayPointer += (offset * sizeof(uint8_t));
 
     // compute base64 string length
     outputLength = 4 * ((length + 2) / 3);
 
     // need malloc with base64 string length plus string terminator (+1)
-    outArray = (char *)platform_malloc(outputLength + 1);
+    outArray = (unsigned char *)platform_malloc(outputLength + 1);
 
     // check if have allocation
     if (outArray == NULL)
@@ -627,8 +627,7 @@ HRESULT Library_corlib_native_System_Convert::ToBase64String___STATIC__STRING__S
 
     // perform the operation
     // need to tweak the parameter with the output length because it includes room for the terminator
-    result =
-        mbedtls_base64_encode((unsigned char *)outArray, (outputLength + 1), &outputLength, inArrayPointer, length);
+    result = mbedtls_base64_encode(outArray, (outputLength + 1), &outputLength, inArrayPointer, length);
 
     if (result != 0)
     {
@@ -645,7 +644,7 @@ HRESULT Library_corlib_native_System_Convert::ToBase64String___STATIC__STRING__S
         // break
         outArrayWitLineBreak = (char *)platform_malloc(outputLength + (lineBreakCount * 2) + 2);
 
-        for (int i = 0; i <= lineBreakCount; i++)
+        for (size_t i = 0; i <= lineBreakCount; i++)
         {
             // how many chars to copy
             if (outputLength > 76)
@@ -694,7 +693,7 @@ HRESULT Library_corlib_native_System_Convert::ToBase64String___STATIC__STRING__S
     {
         // set a return result in the stack argument using the appropriate SetResult according to the variable type (a
         // string here)
-        NANOCLR_CHECK_HRESULT(stack.SetResult_String(outArray));
+        NANOCLR_CHECK_HRESULT(stack.SetResult_String((const char *)outArray));
     }
 
     // need to free memory from arrays
@@ -721,11 +720,11 @@ HRESULT Library_corlib_native_System_Convert::FromBase64String___STATIC__SZARRAY
 #if (SUPPORT_ANY_BASE_CONVERSION == TRUE)
 
     CLR_RT_HeapBlock_String *inString = NULL;
-    uint32_t outputLength;
-    char *outArray = NULL;
+    size_t outputLength;
+    unsigned char *outArray = NULL;
     CLR_UINT8 *returnArray;
-    uint16_t result;
-    uint32_t length;
+    int result;
+    size_t length;
 
     inString = stack.Arg0().DereferenceString();
     FAULT_ON_NULL(inString);
@@ -738,19 +737,21 @@ HRESULT Library_corlib_native_System_Convert::FromBase64String___STATIC__SZARRAY
     outputLength = length / 4 * 3;
 
     // alloc output array
-    outArray = (char *)platform_malloc(outputLength + 1);
+    outArray = (unsigned char *)platform_malloc(outputLength + 1);
     // check malloc success
     if (outArray == NULL)
     {
         NANOCLR_SET_AND_LEAVE(CLR_E_OUT_OF_MEMORY);
     }
 
+    memset(outArray, 0, outputLength + 1);
+
     // perform the operation
     // need to tweak the parameter with the output length because it includes room for the terminator
     result = mbedtls_base64_decode(
-        (unsigned char *)outArray,
-        (size_t)(outputLength + 1),
-        (size_t *)&outputLength,
+        outArray,
+        (outputLength + 1),
+        &outputLength,
         (const unsigned char *)inString->StringText(),
         length);
 

src/CLR/Helpers/Base64/base64.c

@@ -18,16 +18,6 @@
 
 #include "base64.h"
 
-// from MbedTLS common.h
-#define MBEDTLS_BYTE_0( x ) ( (uint8_t) (   ( x )         & 0xff ) )
-#define MBEDTLS_BYTE_1( x ) ( (uint8_t) ( ( ( x ) >> 8  ) & 0xff ) )
-#define MBEDTLS_BYTE_2( x ) ( (uint8_t) ( ( ( x ) >> 16 ) & 0xff ) )
-#define MBEDTLS_BYTE_3( x ) ( (uint8_t) ( ( ( x ) >> 24 ) & 0xff ) )
-#define MBEDTLS_BYTE_4( x ) ( (uint8_t) ( ( ( x ) >> 32 ) & 0xff ) )
-#define MBEDTLS_BYTE_5( x ) ( (uint8_t) ( ( ( x ) >> 40 ) & 0xff ) )
-#define MBEDTLS_BYTE_6( x ) ( (uint8_t) ( ( ( x ) >> 48 ) & 0xff ) )
-#define MBEDTLS_BYTE_7( x ) ( (uint8_t) ( ( ( x ) >> 56 ) & 0xff ) )
-
 unsigned char mbedtls_ct_uchar_mask_of_range( unsigned char low,
                                               unsigned char high,
                                               unsigned char c )
@@ -237,4 +227,4 @@ __nfweak int mbedtls_base64_decode( unsigned char *dst, size_t dlen, size_t *ole
     return( 0 );
 }
 
-// clang-format on
+// clang-format on

src/CLR/Helpers/Base64/base64.h

@@ -1,4 +1,4 @@
-//
+//
 // Copyright (c) .NET Foundation and Contributors
 // Portions Copyright (c) The Mbed TLS Contributors. All Rights Reserved.
 // See LICENSE file in the project root for full license information.
@@ -15,9 +15,14 @@
 // thus there will be no duplicate code                                                     //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
-#define BASE64_SIZE_T_MAX                    ((size_t)-1) /* SIZE_T_MAX is not standard */
-#define MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL  -0x002A      /**< Output buffer too small. */
-#define MBEDTLS_ERR_BASE64_INVALID_CHARACTER -0x002C      /**< Invalid character in input. */
+#define BASE64_SIZE_T_MAX                    ((size_t) - 1) /* SIZE_T_MAX is not standard */
+#define MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL  -0x002A        /**< Output buffer too small. */
+#define MBEDTLS_ERR_BASE64_INVALID_CHARACTER -0x002C        /**< Invalid character in input. */
+
+// from MbedTLS common.h
+#define MBEDTLS_BYTE_0(x) ((uint8_t)((x) & 0xff))
+#define MBEDTLS_BYTE_1(x) ((uint8_t)(((x) >> 8) & 0xff))
+#define MBEDTLS_BYTE_2(x) ((uint8_t)(((x) >> 16) & 0xff))
 
 #ifdef __cplusplus
 extern "C"