Remove alloc on benchmarks + extrachecks on DecodeUrlSSE

Author: Nick-Nuon

benchmark/Benchmark.cs

@@ -299,11 +299,12 @@ public unsafe void RunSSEDecodingBenchmarkUTF16(string[] data, int[] lengths)
             for (int i = 0; i < FileContent.Length; i++)
             {
                 string s = FileContent[i];
-                char[] base64 = s.ToCharArray();
+                // char[] base64 = s.ToCharArray();
+                ReadOnlySpan<char> base64 = s.AsSpan();
                 byte[] dataoutput = output[i];
                 int bytesConsumed = 0;
                 int bytesWritten = 0;
-                SimdBase64.Base64.DecodeFromBase64SSE(base64.AsSpan(), dataoutput, out bytesConsumed, out bytesWritten, false);
+                SimdBase64.Base64.DecodeFromBase64SSE(base64, dataoutput, out bytesConsumed, out bytesWritten, false);
                 if (bytesWritten != lengths[i])
                 {
                     Console.WriteLine($"Error: {bytesWritten} != {lengths[i]}");

src/Base64SSEUTF16.cs

@@ -554,6 +554,23 @@ private unsafe static OperationStatus InnerDecodeFromBase64SSEUrl(ReadOnlySpan<c
                         int lastBlockSrcCount = 0;
                         while ((bufferPtr - startOfBuffer) % 64 != 0 && src < srcEnd)
                         {
+
+                            if (!IsValidBase64Index(*src))
+                            {
+                                bytesConsumed = Math.Max(0, (int)(src - srcInit) - lastBlockSrcCount - (int)bufferBytesConsumed);
+                                bytesWritten = Math.Max(0, (int)(dst - dstInit) - (int)bufferBytesWritten);
+
+                                int remainderBytesConsumed = 0;
+                                int remainderBytesWritten = 0;
+
+                                OperationStatus result =
+                                    Base64WithWhiteSpaceToBinaryScalar(source.Slice(Math.Max(0, bytesConsumed)), dest.Slice(Math.Max(0, bytesWritten)), out remainderBytesConsumed, out remainderBytesWritten, isUrl);
+
+                                bytesConsumed += remainderBytesConsumed;
+                                bytesWritten += remainderBytesWritten;
+                                return result;
+                            }
+
                             byte val = toBase64[(int)*src];
                             *bufferPtr = val;
                             if (val > 64)
@@ -625,6 +642,14 @@ private unsafe static OperationStatus InnerDecodeFromBase64SSEUrl(ReadOnlySpan<c
 
                             while (leftover < 4 && src < srcEnd)
                             {
+
+                                if (!IsValidBase64Index(*src))
+                                {
+                                    bytesConsumed = (int)(src - srcInit);
+                                    bytesWritten = (int)(dst - dstInit);
+                                    return OperationStatus.InvalidData;
+                                }
+                                
                                 byte val = toBase64[(byte)*src];
                                 if (val > 64)
                                 {

test/Base64DecodingTestsUTF16.cs

@@ -305,7 +305,7 @@ protected void RoundtripBase64UrlUTF16(Base64WithWhiteSpaceToBinaryFromUTF16 Bas
 #pragma warning disable CA5394 // Do not use insecure randomness
             random.NextBytes(source);
 
-            string base64String = Convert.ToBase64String(source).Replace('+', '-').Replace('/', '_'); ;
+            string base64String = Convert.ToBase64String(source).Replace('+', '-').Replace('/', '_');
 
             byte[] decodedBytes = new byte[len];
 
@@ -1372,6 +1372,68 @@ public void TruncatedCharErrorUTF16SSE()
         TruncatedCharErrorUTF16(Base64.DecodeFromBase64SSE,Base64.SafeBase64ToBinaryWithWhiteSpace);
     }
 
+    protected void TruncatedCharErrorUrlUTF16(Base64WithWhiteSpaceToBinaryFromUTF16 Base64WithWhiteSpaceToBinaryFromUTF16,DecodeFromBase64DelegateSafeFromUTF16 DecodeFromBase64DelegateSafeFromUTF16)
+    {
+
+        string badNonASCIIString = "♡♡♡♡";
+
+        for (int len = 0; len < 2048; len++)
+        {
+            byte[] source = new byte[len];
+
+            for (int trial = 0; trial < 10; trial++)
+            {
+                int bytesConsumed = 0;
+                int bytesWritten = 0;
+#pragma warning disable CA5394 // Do not use insecure randomness
+                random.NextBytes(source); // Generate random bytes for source
+
+                string base64 = Convert.ToBase64String(source).Replace('+', '-').Replace('/', '_');
+
+                int location = random.Next(0, base64.Length + 1)/4;
+
+                char[] base64WithGarbage = base64.Insert(location, badNonASCIIString).ToCharArray();
+
+                // Prepare a buffer for decoding the base64 back to binary
+                byte[] back = new byte[Base64.MaximalBinaryLengthFromBase64Scalar<char>(base64WithGarbage)];
+
+                // Attempt to decode base64 back to binary and assert that it fails with INVALID_BASE64_CHARACTER
+                var result = Base64WithWhiteSpaceToBinaryFromUTF16(
+                    base64WithGarbage.AsSpan(), back.AsSpan(),
+                    out bytesConsumed, out bytesWritten, isUrl: true);
+                Assert.True(OperationStatus.InvalidData == result, $"OperationStatus {result} is not Invalid Data, error at location {location}. ");
+                Assert.Equal(location, bytesConsumed);
+                Assert.Equal(location / 4 * 3, bytesWritten);
+
+                // Also test safe decoding with a specified back_length
+                var safeResult = DecodeFromBase64DelegateSafeFromUTF16(
+                    base64WithGarbage.AsSpan(), back.AsSpan(),
+                    out bytesConsumed, out bytesWritten, isUrl: true);
+                Assert.Equal(OperationStatus.InvalidData, safeResult);
+                Assert.Equal(location, bytesConsumed);
+                Assert.Equal(location / 4 * 3, bytesWritten);
+
+            }
+        }
+
+        
+    }
+
+    [Fact]
+    [Trait("Category", "scalar")]
+    public void TruncatedCharErrorUrlScalarUTF16()
+    {
+        TruncatedCharErrorUrlUTF16(Base64.Base64WithWhiteSpaceToBinaryScalar,Base64.SafeBase64ToBinaryWithWhiteSpace);
+    }
+
+
+    [Fact]
+    [Trait("Category", "sse")]
+    public void TruncatedCharErrorUrlUTF16SSE()
+    {
+        TruncatedCharErrorUrlUTF16(Base64.DecodeFromBase64SSE,Base64.SafeBase64ToBinaryWithWhiteSpace);
+    }
+
 
 }