code cleanup

Author: hamzamahmood

APIMatic.Core.Test/Security/Cryptography/DigestCodecTests.cs

@@ -20,7 +20,6 @@ public void DigestCodec_Decode_Success(EncodingType encodingType, string input,
 
         [TestCase(EncodingType.Hex, "")]
         [TestCase(EncodingType.Hex, null)]
-        [TestCase(EncodingType.Hex, "ABC")]
         [TestCase(EncodingType.Base64, "")]
         [TestCase(EncodingType.Base64, null)]
         [TestCase(EncodingType.Base64Url, "")]
@@ -31,11 +30,18 @@ public void DigestCodecIncorrectInput_Decode_DigestCodec_Create_Exception(Encodi
             Assert.Throws<ArgumentException>(() => codec.Decode(input));
         }
 
+        [TestCase(EncodingType.Hex, "ABC")]
+        public void DigestCodecIncorrectFormat_Decode_DigestCodec_Create_Exception(EncodingType encodingType, string input)
+        {
+            var codec = DigestCodecFactory.Create(encodingType);
+            Assert.Throws<FormatException>(() => codec.Decode(input));
+        }
+        
         [TestCase(-1)]
         public void DigestCodec_Create_Exception(int invalidValue)
         {
             var encodingType = (EncodingType)invalidValue;
-            Assert.Throws<ArgumentOutOfRangeException>(() => DigestCodecFactory.Create(encodingType));
+            Assert.Throws<NotSupportedException>(() => DigestCodecFactory.Create(encodingType));
         }
     }
 }

APIMatic.Core.Test/Security/SignatureVerifier/SignatureVerificationExtensionsTests.cs

@@ -15,7 +15,7 @@ public class SignatureVerificationExtensionsTests
         [TestCase(new byte[] { 1, 2, 3, 4 }, new byte[] { 1, 2, 3, 5 }, false)]
         public void ConstantTimeEquals_VariousInputs_ReturnsExpected(byte[] a, byte[] b, bool expected)
         {
-            Assert.AreEqual(expected, a.ConstantTimeEquals(b));
+            Assert.AreEqual(expected, SignatureVerifierExtensions.FixedTimeEquals(a, b));
         }
     }
 }

APIMatic.Core.Test/Utilities/IHttpRequestDataExtensionsTests.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using APIMatic.Core.Test.MockTypes.Http.Request;
+using APIMatic.Core.Utilities;
+using NUnit.Framework;
+
+namespace APIMatic.Core.Test.Utilities
+{
+    [TestFixture]
+    public class IHttpRequestDataExtensionsTests
+    {
+        
+        [TestCase(null, new byte[0])]
+        [TestCase("", new byte[0])]
+        [TestCase("hello", new byte[] { 104, 101, 108, 108, 111 })]
+        public async Task ReadBodyStreamToByteArrayAsync_VariousBodies_ReturnsExpected(string body, byte[] expected)
+        {
+            var stream = body == null ? null : new MemoryStream(Encoding.UTF8.GetBytes(body));
+            var request = new HttpRequestData(new Dictionary<string, string[]>(), stream);
+
+            var result = await request.ReadBodyStreamToByteArrayAsync();
+
+            Assert.AreEqual(expected, result);
+        }
+    }
+}

APIMatic.Core.Test/Utilities/Json/JsonPointerResolverTest.cs

@@ -81,5 +81,18 @@ public void ResolveScopedJsonValue_BooleanToken_ReturnsTokenToString()
 
             Assert.AreEqual("True", result);
         }
+        
+        [TestCase("#/name", "{\"name\":\"John\",\"age\":30}", "John")]
+        [TestCase("#/invalid", "{\"name\":\"John\"}", null)]
+        [TestCase(null, "{\"name\":\"John\"}", null)]
+        [TestCase("", "{\"name\":\"John\"}", null)]
+        [TestCase("/name", "{\"name\":\"John\"}", null)]
+        [TestCase("#/age", "{\"age\":30}", "30")]
+        [TestCase("#/name", null, null)]
+        public void ResolveJsonValue_VariousCases_ReturnsExpected(string jsonPointer, string json, string expected)
+        {
+            var result = JsonPointerResolver.ResolveJsonValue(jsonPointer, json);
+            Assert.AreEqual(expected, result);
+        }
     }
 }

APIMatic.Core/Security/Cryptography/Base64UrlDigestCodec.cs

@@ -12,6 +12,7 @@ public class Base64UrlDigestCodec : IDigestCodec
         /// </summary>
         /// <param name="encoded">The Base64Url string to decode.</param>
         /// <returns>The decoded byte array.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when the input is null.</exception>
         /// <exception cref="FormatException">Thrown when the input is not a valid Base64Url string.</exception>
         public byte[] Decode(string encoded)
         {

APIMatic.Core/Security/Cryptography/DigestCodecFactory.cs

@@ -11,18 +11,17 @@ public static class DigestCodecFactory
         /// <summary>
         /// Creates a digest codec for the specified encoding type.
         /// </summary>
-        /// <param name="digestEncoding">The encoding type to use.</param>
+        /// <param name="encodingType">The encoding type to use.</param>
         /// <returns>A digest codec instance.</returns>
         /// <exception cref="ArgumentOutOfRangeException">Thrown when an unsupported encoding type is specified.</exception>
-        public static IDigestCodec Create(EncodingType digestEncoding)
+        public static IDigestCodec Create(EncodingType encodingType)
         {
-            return digestEncoding switch
+            return encodingType switch
             {
                 EncodingType.Hex => new HexDigestCodec(),
                 EncodingType.Base64 => new Base64DigestCodec(),
                 EncodingType.Base64Url => new Base64UrlDigestCodec(),
-                _ => throw new ArgumentOutOfRangeException(nameof(digestEncoding),
-                    $"Unsupported encoding type: {digestEncoding}")
+                _ => throw new NotSupportedException($"Unsupported encoding type: {encodingType}")
             };
         }
     }

APIMatic.Core/Security/Cryptography/HexDigestCodec.cs

@@ -4,7 +4,7 @@
 namespace APIMatic.Core.Security.Cryptography
 {
     /// <summary>
-    /// encodedadecimal digest codec implementation.
+    /// HexDigestCodec digest codec implementation.
     /// </summary>
     public class HexDigestCodec : IDigestCodec
     {
@@ -25,7 +25,7 @@ public byte[] Decode(string encoded)
 
             // Hex string must have even length
             if (encoded.Length % 2 != 0)
-                throw new ArgumentException("Hexadecimal string must have even length", nameof(encoded));
+                throw new FormatException("Hexadecimal string must have even length");
 
             byte[] bytes = new byte[encoded.Length / 2];
 

APIMatic.Core/Security/SignatureVerifier/HmacSignatureVerifier.cs

@@ -47,6 +47,8 @@ public class HmacSignatureVerifier : ISignatureVerifier
         /// Codec used for encoding and decoding digests based on the specified encoding type.
         /// </summary>
         private readonly IDigestCodec _digestCodec;
+        
+        private const string DigestPlaceHolder = "{digest}";
 
         /// <summary>
         /// Initializes a new instance of the HmacSignatureVerifier class.
@@ -81,7 +83,7 @@ public HmacSignatureVerifier(
                                                          await request.ReadBodyStreamToByteArrayAsync(cancellationToken)
                                                              .ConfigureAwait(false));
         }
-
+        
         /// <summary>
         /// Verifies the HMAC signature of the specified HTTP request.
         /// </summary>
@@ -114,7 +116,7 @@ public async Task<VerificationResult> VerifyAsync(IHttpRequestData request,
             {
                 var computedHash = hmac.ComputeHash(resolvedTemplateBytes);
 
-                return providedSignature.ConstantTimeEquals(computedHash)
+                return SignatureVerifierExtensions.FixedTimeEquals(computedHash, providedSignature)
                     ? VerificationResult.Success()
                     : VerificationResult.Failure(new[] { "Signature verification failed." });
             }
@@ -132,16 +134,16 @@ private static string ExtractDigestFromTemplate(string signatureValue, string si
                 return string.Empty;
 
             // If template is just "{digest}", return the signature as-is
-            if (signatureValueTemplate == "{digest}")
+            if (signatureValueTemplate == DigestPlaceHolder)
                 return signatureValue;
 
             // Extract digest from template
-            var digestIndex = signatureValueTemplate.IndexOf("{digest}", StringComparison.Ordinal);
+            var digestIndex = signatureValueTemplate.IndexOf(DigestPlaceHolder, StringComparison.Ordinal);
             if (digestIndex == -1)
                 return string.Empty;
 
             var prefix = signatureValueTemplate[..digestIndex];
-            var suffix = signatureValueTemplate[(digestIndex + 8)..];
+            var suffix = signatureValueTemplate[(digestIndex + DigestPlaceHolder.Length)..];
 
             if (!signatureValue.StartsWith(prefix) || !signatureValue.EndsWith(suffix))
                 return string.Empty;

APIMatic.Core/Security/SignatureVerifier/SignatureVerifierExtensions.cs

@@ -1,31 +1,41 @@
+using System;
+using System.Runtime.CompilerServices;
+
 namespace APIMatic.Core.Security.SignatureVerifier
 {
     internal static class SignatureVerifierExtensions
     {
         /// <summary>
         /// Performs a secure comparison of two byte arrays to prevent timing attacks.
         /// </summary>
-        /// <param name="a">First byte array.</param>
-        /// <param name="b">Second byte array.</param>
+        /// <param name="left">First byte array.</param>
+        /// <param name="right">Second byte array.</param>
         /// <returns>True if arrays are equal, false otherwise.</returns>
-        public static bool ConstantTimeEquals(this byte[] a, byte[] b)
+        /// <remarks>
+        /// This implementation is copied from CryptographicOperations in System.Security.Cryptography
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
+        public static bool FixedTimeEquals(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right)
         {
-            if (a == null && b == null)
-                return true;
-
-            if (a == null || b == null)
-                return false;
-
-            if (a.Length != b.Length)
+            // NoOptimization because we want this method to be exactly as non-short-circuiting
+            // as written.
+            //
+            // NoInlining because the NoOptimization would get lost if the method got inlined.
+ 
+            if (left.Length != right.Length)
+            {
                 return false;
-
-            var result = 0;
-            for (int i = 0; i < a.Length; i++)
+            }
+ 
+            int length = left.Length;
+            int accum = 0;
+ 
+            for (int i = 0; i < length; i++)
             {
-                result |= a[i] ^ b[i];
+                accum |= left[i] - right[i];
             }
-
-            return result == 0;
+ 
+            return accum == 0;
         }
     }
 }