Added base64 checksum output

Author: antoniopereirabuilds

OutSystems.NetChecksumUtils.UnitTests/NetChecksumUtils.ComputeChecksum.Tests.cs

@@ -34,6 +34,19 @@ private static string GetExpectedHash(string algorithm, string text)
             };
         }
 
+        private static string GetExpectedBase64(string algorithm, string text)
+        {
+            byte[] data = Encoding.UTF8.GetBytes(text);
+            return algorithm.Trim().ToUpperInvariant() switch
+            {
+                "SHA256" or "SHA-256" => Convert.ToBase64String(SHA256.HashData(data)),
+                "SHA512" or "SHA-512" => Convert.ToBase64String(SHA512.HashData(data)),
+                "SHA3_256" or "SHA3-256" => Convert.ToBase64String(SHA3_256.HashData(data)),
+                "MD5" => Convert.ToBase64String(MD5.HashData(data)),
+                _ => throw new ArgumentException("Unsupported algorithm in test helper", nameof(algorithm))
+            };
+        }
+
         #endregion
 
         #region ComputeChecksum Tests
@@ -53,12 +66,13 @@ public void ComputeChecksum_ValidInput_ReturnsCorrectHash(string algorithm, stri
             string expected = GetExpectedHash(algorithm, text);
 
             // Act
-            _sut.ComputeChecksum(algorithm, text, out string actual, out long ticks);
+            _sut.ComputeChecksum(algorithm, text, out string actualHex, out string actualBase64, out long ticks);
 
             // Assert
             Assert.Multiple(() =>
             {
-                Assert.That(actual, Is.EqualTo(expected), $"Hash mismatch for {algorithm}");
+                Assert.That(actualHex, Is.EqualTo(expected), $"Hex hash mismatch for {algorithm}");
+                Assert.That(actualBase64, Is.EqualTo(GetExpectedBase64(algorithm, text)), $"Base64 hash mismatch for {algorithm}");
                 Assert.That(ticks, Is.GreaterThanOrEqualTo(0), "Duration should be non-negative.");
             });
         }
@@ -120,8 +134,8 @@ public void Methods_NullInputs_ThrowArgumentNullException()
             Assert.Multiple(() =>
             {
                 // ComputeChecksum null checks
-                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum(null!, "text", out _, out _));
-                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum("SHA256", null!, out _, out _));
+                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum(null!, "text", out _, out _, out _));
+                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum("SHA256", null!, out _, out _, out _));
 
                 // VerifyChecksum null checks
                 Assert.Throws<ArgumentNullException>(() => _sut.VerifyChecksum(null!, "text", "hash", out _, out _));
@@ -139,7 +153,7 @@ public void Methods_NullInputs_ThrowArgumentNullException()
         public void Methods_InvalidAlgorithm_ThrowsArgumentException(string invalidAlgo)
         {
             Assert.Throws<ArgumentException>(() => 
-                _sut.ComputeChecksum(invalidAlgo, "text", out _, out _));
+                _sut.ComputeChecksum(invalidAlgo, "text", out _, out _, out _));
         }
 
         #endregion

OutSystems.NetChecksumUtils/INetChecksumUtils.cs

@@ -22,6 +22,8 @@ void ComputeChecksum(
             string textToHash,
             [OSParameterAttribute(Description = "Output parameter that receives the computed checksum as an uppercase hexadecimal string.")]
             out string checksumText,
+            [OSParameterAttribute(Description = "Output parameter that receives the computed checksum as a Base64 string.")]
+            out string checksumBase64,
             [OSParameterAttribute(Description = "Output parameter that receives the duration of the hashing operation in ticks.")]
             out long operationDuration
         );
@@ -35,7 +37,7 @@ void VerifyChecksum(
             string algorithm,
             [OSParameterAttribute(Description = "The name of the hashing algorithm to use. Supported values (case-insensitive): \"SHA256\", \"SHA-256\", \"SHA512\", \"SHA-512\", \"MD5\", \"SHA3-256\", \"SHA3_256\".")]
             string text,
-            [OSParameterAttribute(Description = "The text to compute the checksum for. The text is encoded as UTF-8 before hashing.")]
+            [OSParameterAttribute(Description = "The text to compute the checksum for uppercase hex or base64). The text is encoded as UTF-8 before hashing.")]
             string existingChecksum,
             [OSParameterAttribute(Description = "Output parameter that receives the computed checksum as an uppercase hexadecimal string.")]
             out bool isValid,

OutSystems.NetChecksumUtils/NetChecksumUtils.cs

@@ -12,12 +12,12 @@ namespace OutSystems.NetChecksumUtils
     /// </summary>
     public class NetChecksumUtils : INetChecksumUtils
     {
-        static (string Hex, TimeSpan Elapsed) ComputeChecksum(Func<byte[], byte[]> hashFunc, byte[] bytes)
+        static (byte[] HashBytes, TimeSpan Elapsed) ComputeChecksum(Func<byte[], byte[]> hashFunc, byte[] bytes)
         {
             var sw = Stopwatch.StartNew();
             byte[] hashBytes = hashFunc(bytes);
             sw.Stop();
-            return (Convert.ToHexString(hashBytes), sw.Elapsed);
+            return (hashBytes, sw.Elapsed);
         }
 
         /// <summary>
@@ -59,7 +59,7 @@ private static Func<byte[], byte[]> GetHashFunction(string algorithm)
         /// <exception cref="ArgumentException">Thrown when <paramref name="algorithm"/> is not recognized/supported.</exception>
         public void ComputeChecksum(
             string algorithm, string textToHash,
-            out string checksumText, out long operationDurationInTicks)
+            out string checksumTextHex, out string checksumTextBase64, out long operationDurationInTicks)
         {
             // Ensure inputs are not null before proceeding
             ArgumentNullException.ThrowIfNull(algorithm);
@@ -72,10 +72,11 @@ public void ComputeChecksum(
             var hashFunc = GetHashFunction(algorithm);
 
             // 3. Execute the hashing logic and measure performance.
-            var (computedChecksum, elapsed) = ComputeChecksum(hashFunc, inputBytes);
+            var (hashBytes, elapsed) = ComputeChecksum(hashFunc, inputBytes);
 
-            // 4. Assign results to output parameters
-            checksumText = computedChecksum;
+            // 4. Assign results to output parameters (hex + base64)
+            checksumTextHex = Convert.ToHexString(hashBytes);
+            checksumTextBase64 = Convert.ToBase64String(hashBytes);
             operationDurationInTicks = elapsed.Ticks;
         }
 
@@ -87,7 +88,7 @@ public void ComputeChecksum(
         /// "SHA256", "SHA-256", "SHA512", "SHA-512", "MD5".
         /// </param>
         /// <param name="text">The input text to hash (UTF-8 encoded before hashing).</param>
-        /// <param name="existingChecksum">The checksum to compare against (hex string).</param>
+        /// <param name="existingChecksum">The checksum to compare against (base64 or hex string).</param>
         /// <param name="isValid">Output parameter set to true when the computed checksum equals <paramref name="existingChecksum"/> (case-insensitive).</param>
         /// <param name="operationDuration">Output parameter that receives the duration, in ticks, of the entire verification operation (includes hashing + comparison).</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="algorithm"/>, <paramref name="text"/> or <paramref name="existingChecksum"/> is null.</exception>
@@ -109,8 +110,11 @@ public void VerifyChecksum(
 
             // 3. Measure the whole operation: hashing + comparison
             var sw = Stopwatch.StartNew();
-            var (newChecksum, _) = ComputeChecksum(hashFunc, inputBytes);
-            isValid = string.Equals(newChecksum, existingChecksum, StringComparison.OrdinalIgnoreCase);
+            var (hashBytes, _) = ComputeChecksum(hashFunc, inputBytes);
+            var newHex = Convert.ToHexString(hashBytes);
+            var newBase64 = Convert.ToBase64String(hashBytes);
+            isValid = string.Equals(newHex, existingChecksum, StringComparison.OrdinalIgnoreCase)
+                || string.Equals(newBase64, existingChecksum, StringComparison.Ordinal);
             sw.Stop();
 
             // 4. Return operation duration in ticks (includes comparison step)