Merged PR 41316: Use Marvin32 instead of xxHash32 in COSE hash codes

Author: bartonjs

src/libraries/Common/src/System/HashCodeRandomization.cs

@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+
 namespace System
 {
     // Contains helpers for calculating randomized hash codes of common types.
@@ -14,39 +17,33 @@ namespace System
     // rather than a global seed for the entire AppDomain.
     internal static class HashCodeRandomization
     {
+#if !NET
+        private static readonly ulong s_seed = GenerateSeed();
+
+        private static ulong GenerateSeed()
+        {
+            using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
+            {
+                byte[] rand = new byte[sizeof(ulong)];
+                rng.GetBytes(rand);
+
+                return BitConverter.ToUInt64(rand, 0);
+            }
+        }
+#endif
+
         public static int GetRandomizedOrdinalHashCode(this string value)
         {
 #if NETCOREAPP
             // In .NET Core, string hash codes are already randomized.
 
             return value.GetHashCode();
 #else
-            // Downlevel, we need to perform randomization ourselves. There's still
-            // the potential for limited collisions ("Hello!" and "Hello!\0"), but
-            // this shouldn't be a problem in practice. If we need to address it,
-            // we can mix the string length into the accumulator before running the
-            // string contents through.
-            //
-            // We'll pull out pairs of chars and write 32 bits at a time.
-
-            HashCode hashCode = default;
-            int pair = 0;
-            for (int i = 0; i < value.Length; i++)
-            {
-                int ch = value[i];
-                if ((i & 1) == 0)
-                {
-                    pair = ch << 16; // first member of pair
-                }
-                else
-                {
-                    pair |= ch; // second member of pair
-                    hashCode.Add(pair); // write pair as single unit
-                    pair = 0;
-                }
-            }
-            hashCode.Add(pair); // flush any leftover data (could be 0 or 1 chars)
-            return hashCode.ToHashCode();
+            // Downlevel, we need to perform randomization ourselves.
+
+            ReadOnlySpan<char> charSpan = value.AsSpan();
+            ReadOnlySpan<byte> byteSpan = MemoryMarshal.AsBytes(charSpan);
+            return Marvin.ComputeHash32(byteSpan, s_seed);
 #endif
         }
 

src/libraries/System.Private.CoreLib/src/System/Marvin.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -204,7 +203,7 @@ public static int ComputeHash32(ref byte data, uint count, uint p0, uint p1)
                 else
                 {
                     partialResult |= (uint)Unsafe.ReadUnaligned<ushort>(ref data);
-                    partialResult = BitOperations.RotateLeft(partialResult, 16);
+                    partialResult = RotateLeft(partialResult, 16);
                 }
             }
 
@@ -221,21 +220,26 @@ private static void Block(ref uint rp0, ref uint rp1)
             uint p1 = rp1;
 
             p1 ^= p0;
-            p0 = BitOperations.RotateLeft(p0, 20);
+            p0 = RotateLeft(p0, 20);
 
             p0 += p1;
-            p1 = BitOperations.RotateLeft(p1, 9);
+            p1 = RotateLeft(p1, 9);
 
             p1 ^= p0;
-            p0 = BitOperations.RotateLeft(p0, 27);
+            p0 = RotateLeft(p0, 27);
 
             p0 += p1;
-            p1 = BitOperations.RotateLeft(p1, 19);
+            p1 = RotateLeft(p1, 19);
 
             rp0 = p0;
             rp1 = p1;
         }
 
+#if SYSTEM_PRIVATE_CORELIB
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft(uint value, int offset) =>
+            System.Numerics.BitOperations.RotateLeft(value, offset);
+
         public static ulong DefaultSeed { get; } = GenerateSeed();
 
         private static unsafe ulong GenerateSeed()
@@ -244,5 +248,10 @@ private static unsafe ulong GenerateSeed()
             Interop.GetRandomBytes((byte*)&seed, sizeof(ulong));
             return seed;
         }
+#else
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft(uint value, int offset) =>
+            (value << offset) | (value >> (32 - offset));
+#endif
     }
 }

src/libraries/System.Security.Cryptography.Cose/src/System.Security.Cryptography.Cose.csproj

@@ -4,6 +4,8 @@
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsPackable>true</IsPackable>
+    <ServicingVersion>1</ServicingVersion>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageDescription>Provides support for CBOR Object Signing and Encryption (COSE).</PackageDescription>
   </PropertyGroup>
 
@@ -33,13 +35,12 @@
     <Compile Include="System\Security\Cryptography\Cose\SigStructureContext.cs" />
   </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Formats.Cbor\src\System.Formats.Cbor.csproj" />
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+      <Compile Include="$(CoreLibSharedDir)System\Marvin.cs" Link="CoreLib\System\Marvin.cs" />
   </ItemGroup>
 
-  <!-- For System.HashCode -->
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
-    <PackageReference Include="Microsoft.Bcl.HashCode" Version="$(MicrosoftBclHashCodeVersion)" />
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Formats.Cbor\src\System.Formats.Cbor.csproj" />
   </ItemGroup>
 
 </Project>