Byte Array Constant Time Compare

I am writing a function that does a constant time compare of two byte arrays. I want it to be constant time to insure there is no side channel attacks possible.

1. Does the code protect against timing attacks or other side channel attacks (of which I could fix)
2. Any other suggestions for improvements

Note: This code is called infrequently so performance is not a big deal

/// <summary>
/// Performs a comparison of two identical sized byte arrays. 
/// Performs in constant time to prevent timing/side channel attacks
/// </summary>
public int CompareConstantTime(byte[] bytesA, byte[] bytesB)
{
    if (bytesA == null)
        throw new ArgumentNullException(nameof(bytesA));
    if (bytesB == null)
        throw new ArgumentNullException(nameof(bytesB));
    if (bytesA.Length != bytesB.Length)
        throw new ArgumentOutOfRangeException("byte length must be equal");

    //only the lest significant bit is used
    int aIsLarger = 0;
    int bIsLarger = 0;

    unchecked
    {
        for (int i = 0; i < bytesA.Length; i++)
        {
            int byteA = bytesA[i];
            int byteB = bytesB[i];

            int byteAIsLarger = ((byteB - byteA) >> 8) & 1;
            int byteBIsLarger = ((byteA - byteB) >> 8) & 1;

            aIsLarger = aIsLarger | (byteAIsLarger & ~bIsLarger);
            bIsLarger = bIsLarger | (byteBIsLarger & ~aIsLarger);
        }

        //fixes to standard compaire results (0 if A = B, 1 if A > B, -1: B > A)
        int result = aIsLarger - bIsLarger;
        return result;
    }
}