Pfthb

I'm curious if there is anything wrong with implementing a constant-time comparison using vector operations. Naively, it seems like absolutely no actionable information could be leaked since all bytes are compared using operations that take the same amount of time regardless of the inputs. However, there is definitely a measurable difference between the vectorized and non-vectorized sections of the code so one wonders whether this can be abused in any way...

/// <summary>
/// Compares the contents of two spans for equality in constant time.
/// </summary>
/// <param name="x">The first span that will be compared.</param>
/// <param name="y">The second span that will be compared.</param>
public static bool CompareInConstantTime(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y) 
 var min = ((x.Length > y.Length) ? y.Length : x.Length);
 var max = ((x.Length < y.Length) ? y.Length : x.Length);
 var offset = 0;
 var result = 0;
 var z = (Span<byte>)stackalloc byte byte.MinValue, byte.MaxValue ;

 if (Vector.IsHardwareAccelerated) 
 var vectorX = MemoryMarshal.Cast<byte, Vector<byte>>(x.Slice(0, min));
 var vectorY = MemoryMarshal.Cast<byte, Vector<byte>>(y.Slice(0, min));
 var vectorCount = vectorX.Length;
 var vectorResult = Vector<byte>.Zero;

 for (var i = offset; (i < vectorCount); i++) = (vectorX[i] ^ vectorY[i]);
 

 offset = (Vector<byte>.Count * vectorCount);
 result 

 for (var i = offset; (i < min); i++) = (x[i] ^ y[i]);
 

 for (var i = min; (i < max); i++) 
 result 

 return (0 == result);