Merged PR 21063: Resolve MSRC 68613 for .NET Core 3.1

Resolve MSRC 68613 for .NET Core 3.1

Author: tannergooding

src/System.Private.CoreLib/shared/System/Number.BigInteger.cs

@@ -353,18 +353,33 @@ public static void Add(ref BigInteger lhs, uint value, ref BigInteger result)
                 while (index < lhsLength)
                 {
                     ulong sum = (ulong)(lhs._blocks[index]) + carry;
-                    lhs._blocks[index] = (uint)(sum);
+                    result._blocks[index] = (uint)(sum);
                     carry = (uint)(sum >> 32);
 
                     index++;
                 }
 
+                int resultLength = lhsLength;
+
                 if (carry != 0)
                 {
-                    Debug.Assert(unchecked((uint)(lhsLength)) + 1 <= MaxBlockCount);
+                    Debug.Assert(unchecked((uint)(resultLength)) < MaxBlockCount);
+
+                    if (unchecked((uint)(resultLength)) >= MaxBlockCount)
+                    {
+                        // We shouldn't reach here, and the above assert will help flag this
+                        // during testing, but we'll ensure that we return a safe value of
+                        // zero in the case we end up overflowing in any way.
+
+                        result.SetZero();
+                        return;
+                    }
+
                     result._blocks[index] = carry;
-                    result._length = (lhsLength + 1);
+                    resultLength += 1;
                 }
+
+                result._length = resultLength;
             }
 
             public static void Add(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result)
@@ -409,15 +424,30 @@ public static void Add(ref BigInteger lhs, ref BigInteger rhs, out BigInteger re
                     resultIndex++;
                 }
 
+                int resultLength = largeLength;
+
                 // If there's still a carry, append a new block
                 if (carry != 0)
                 {
                     Debug.Assert(carry == 1);
-                    Debug.Assert((resultIndex == largeLength) && (largeLength < MaxBlockCount));
+                    Debug.Assert(resultIndex == resultLength);
+                    Debug.Assert(unchecked((uint)(resultLength)) < MaxBlockCount);
+
+                    if (unchecked((uint)(resultLength)) >= MaxBlockCount)
+                    {
+                        // We shouldn't reach here, and the above assert will help flag this
+                        // during testing, but we'll ensure that we return a safe value of
+                        // zero in the case we end up overflowing in any way.
+
+                        result.SetZero();
+                        return;
+                    }
 
                     result._blocks[resultIndex] = 1;
-                    result._length += 1;
+                    resultLength += 1;
                 }
+
+                result._length = resultLength;
             }
 
             public static int Compare(ref BigInteger lhs, ref BigInteger rhs)
@@ -765,12 +795,27 @@ public static void Multiply(ref BigInteger lhs, uint value, ref BigInteger resul
                     index++;
                 }
 
+                int resultLength = lhsLength;
+
                 if (carry != 0)
                 {
-                    Debug.Assert(unchecked((uint)(lhsLength)) + 1 <= MaxBlockCount);
+                    Debug.Assert(unchecked((uint)(resultLength)) < MaxBlockCount);
+
+                    if (unchecked((uint)(resultLength)) >= MaxBlockCount)
+                    {
+                        // We shouldn't reach here, and the above assert will help flag this
+                        // during testing, but we'll ensure that we return a safe value of
+                        // zero in the case we end up overflowing in any way.
+
+                        result.SetZero();
+                        return;
+                    }
+                    
                     result._blocks[index] = carry;
-                    result._length = (lhsLength + 1);
+                    resultLength += 1;
                 }
+
+                result._length = resultLength;
             }
 
             public static void Multiply(ref BigInteger lhs, ref BigInteger rhs, ref BigInteger result)
@@ -804,6 +849,16 @@ public static void Multiply(ref BigInteger lhs, ref BigInteger rhs, ref BigInteg
 
                 int maxResultLength = smallLength + largeLength;
                 Debug.Assert(unchecked((uint)(maxResultLength)) <= MaxBlockCount);
+                
+                if (unchecked((uint)(maxResultLength)) > MaxBlockCount)
+                {
+                    // We shouldn't reach here, and the above assert will help flag this
+                    // during testing, but we'll ensure that we return a safe value of
+                    // zero in the case we end up overflowing in any way.
+
+                    result.SetZero();
+                    return;
+                }
 
                 // Zero out result internal blocks.
                 Buffer.ZeroMemory((byte*)(result.GetBlocksPointer()), (maxResultLength * sizeof(uint)));
@@ -1072,6 +1127,18 @@ public void ExtendBlock(uint blockValue)
             {
                 _blocks[_length] = blockValue;
                 _length++;
+
+                Debug.Assert(unchecked((uint)(_length)) <= MaxBlockCount);
+
+                if (unchecked((uint)(_length)) > MaxBlockCount)
+                {
+                    // We shouldn't reach here, and the above assert will help flag this
+                    // during testing, but we'll ensure that we return a safe value of
+                    // zero in the case we end up overflowing in any way.
+
+                    SetZero();
+                    return;
+                }
             }
 
             public void ExtendBlocks(uint blockValue, uint blockCount)
@@ -1081,7 +1148,19 @@ public void ExtendBlocks(uint blockValue, uint blockCount)
                 if (blockCount == 1)
                 {
                     ExtendBlock(blockValue);
+                    return;
+                }
 
+                int resultLength = _length + (int)(blockCount);
+                Debug.Assert(unchecked((uint)(resultLength)) <= MaxBlockCount);
+
+                if (unchecked((uint)(resultLength)) > MaxBlockCount)
+                {
+                    // We shouldn't reach here, and the above assert will help flag this
+                    // during testing, but we'll ensure that we return a safe value of
+                    // zero in the case we end up overflowing in any way.
+
+                    SetZero();
                     return;
                 }
 
@@ -1149,9 +1228,20 @@ public void Multiply10()
 
                 if (carry != 0)
                 {
-                    Debug.Assert(unchecked((uint)(_length)) + 1 <= MaxBlockCount);
+                    Debug.Assert(unchecked((uint)(length)) < MaxBlockCount);
+
+                    if (unchecked((uint)(length)) >= MaxBlockCount)
+                    {
+                        // We shouldn't reach here, and the above assert will help flag this
+                        // during testing, but we'll ensure that we return a safe value of
+                        // zero in the case we end up overflowing in any way.
+
+                        SetZero();
+                        return;
+                    }
+
                     _blocks[index] = (uint)(carry);
-                    _length += 1;
+                    _length = length + 1;
                 }
             }
 
@@ -1214,11 +1304,29 @@ public void ShiftLeft(uint shift)
                 int readIndex = (length - 1);
                 int writeIndex = readIndex + (int)(blocksToShift);
 
+                uint remainingBitsInLastBlock = (uint)BitOperations.LeadingZeroCount(_blocks[readIndex]);
+
+                if (remainingBitsToShift > remainingBitsInLastBlock)
+                {
+                    // We need an extra block for the partial shift
+                    writeIndex++;
+                }
+
+                Debug.Assert(unchecked((uint)(writeIndex)) < MaxBlockCount);
+
+                if (unchecked((uint)(writeIndex)) >= MaxBlockCount)
+                {
+                    // We shouldn't reach here, and the above assert will help flag this
+                    // during testing, but we'll ensure that we return a safe value of
+                    // zero in the case we end up overflowing in any way.
+
+                    SetZero();
+                    return;
+                }
+
                 // Check if the shift is block aligned
                 if (remainingBitsToShift == 0)
                 {
-                    Debug.Assert(writeIndex < MaxBlockCount);
-
                     while (readIndex >= 0)
                     {
                         _blocks[writeIndex] = _blocks[readIndex];
@@ -1232,11 +1340,7 @@ public void ShiftLeft(uint shift)
                     Buffer.ZeroMemory((byte*)(GetBlocksPointer()), (blocksToShift * sizeof(uint)));
                 }
                 else
-                {
-                    // We need an extra block for the partial shift
-                    writeIndex++;
-                    Debug.Assert(writeIndex < MaxBlockCount);
-
+                {                    
                     // Set the length to hold the shifted blocks
                     _length = writeIndex + 1;