[release/9.0] Merge RC2 changes into 9.0

src/libraries/Common/src/Interop/Windows/Advapi32/Interop.PERF_INFO.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Runtime.InteropServices;
 
@@ -13,6 +14,17 @@ internal static partial class Advapi32
         internal struct PERF_COUNTER_BLOCK
         {
             internal int ByteLength;
+
+            internal static readonly int SizeOf = Marshal.SizeOf<PERF_COUNTER_BLOCK>();
+
+            public readonly void Validate(int bufferSize)
+            {
+                if (ByteLength < SizeOf ||
+                    ByteLength > bufferSize)
+                {
+                    ThrowInvalidOperationException(typeof(PERF_COUNTER_BLOCK));
+                }
+            }
         }
 
         [StructLayout(LayoutKind.Sequential)]
@@ -28,6 +40,20 @@ internal struct PERF_COUNTER_DEFINITION
             internal int CounterType;
             internal int CounterSize;
             internal int CounterOffset;
+
+            internal static readonly int SizeOf = Marshal.SizeOf<PERF_COUNTER_DEFINITION>();
+
+            public readonly void Validate(int bufferSize)
+            {
+                if (ByteLength < SizeOf ||
+                    ByteLength > bufferSize ||
+                    CounterSize < 0 ||
+                    CounterOffset < 0 ||
+                    CounterOffset > bufferSize)
+                {
+                    ThrowInvalidOperationException(typeof(PERF_COUNTER_DEFINITION));
+                }
+            }
         }
 
         [StructLayout(LayoutKind.Sequential)]
@@ -49,6 +75,23 @@ internal struct PERF_DATA_BLOCK
             internal long PerfTime100nSec;
             internal int SystemNameLength;
             internal int SystemNameOffset;
+
+            internal const int Signature1Int = (int)'P' + ('E' << 16);
+            internal const int Signature2Int = (int)'R' + ('F' << 16);
+            internal static readonly int SizeOf = Marshal.SizeOf<PERF_DATA_BLOCK>();
+
+            public readonly void Validate(int bufferSize)
+            {
+                if (Signature1 != Signature1Int ||
+                    Signature2 != Signature2Int ||
+                    TotalByteLength < SizeOf ||
+                    TotalByteLength > bufferSize ||
+                    HeaderLength < SizeOf ||
+                    HeaderLength > TotalByteLength)
+                {
+                    ThrowInvalidOperationException(typeof(PERF_DATA_BLOCK));
+                }
+            }
         }
 
         [StructLayout(LayoutKind.Sequential)]
@@ -61,9 +104,23 @@ internal struct PERF_INSTANCE_DEFINITION
             internal int NameOffset;
             internal int NameLength;
 
+            internal static readonly int SizeOf = Marshal.SizeOf<PERF_INSTANCE_DEFINITION>();
+
             internal static ReadOnlySpan<char> GetName(in PERF_INSTANCE_DEFINITION instance, ReadOnlySpan<byte> data)
                 => (instance.NameLength == 0) ? default
                     : MemoryMarshal.Cast<byte, char>(data.Slice(instance.NameOffset, instance.NameLength - sizeof(char))); // NameLength includes the null-terminator
+
+            public readonly void Validate(int bufferSize)
+            {
+                if (ByteLength < SizeOf ||
+                    ByteLength > bufferSize ||
+                    NameOffset < 0 ||
+                    NameLength < 0 ||
+                    checked (NameOffset + NameLength) > ByteLength)
+                {
+                    ThrowInvalidOperationException(typeof(PERF_INSTANCE_DEFINITION));
+                }
+            }
         }
 
         [StructLayout(LayoutKind.Sequential)]
@@ -83,6 +140,29 @@ internal struct PERF_OBJECT_TYPE
             internal int CodePage;
             internal long PerfTime;
             internal long PerfFreq;
+
+            internal static readonly int SizeOf = Marshal.SizeOf<PERF_OBJECT_TYPE>();
+
+            public readonly void Validate(int bufferSize)
+            {
+                if (HeaderLength < SizeOf ||
+                    HeaderLength > TotalByteLength ||
+                    HeaderLength > DefinitionLength ||
+                    DefinitionLength < SizeOf ||
+                    DefinitionLength > TotalByteLength ||
+                    TotalByteLength > bufferSize ||
+                    NumCounters < 0 ||
+                    checked
+                    (
+                        // This is a simple check, not exact, since it depends on how instances are specified.
+                        (NumInstances <= 0 ? 0 : NumInstances * PERF_INSTANCE_DEFINITION.SizeOf) +
+                        NumCounters * PERF_COUNTER_DEFINITION.SizeOf
+                    ) > bufferSize
+                )
+                {
+                    ThrowInvalidOperationException(typeof(PERF_OBJECT_TYPE));
+                }
+            }
         }
 
         [StructLayout(LayoutKind.Sequential)]
@@ -106,4 +186,8 @@ public override string ToString()
             }
         }
     }
+
+    [DoesNotReturn]
+    public static void ThrowInvalidOperationException(Type type) =>
+        throw new InvalidOperationException(SR.Format(SR.InvalidPerfData, type.Name));
 }

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.
@@ -21,32 +24,11 @@ public static int GetRandomizedOrdinalHashCode(this string value)
 
             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.
+            // Downlevel, we need to perform randomization ourselves.
 
-            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();
+            ReadOnlySpan<char> charSpan = value.AsSpan();
+            ReadOnlySpan<byte> byteSpan = MemoryMarshal.AsBytes(charSpan);
+            return Marvin.ComputeHash32(byteSpan, Marvin.DefaultSeed);
 #endif
         }