Big-endian fixes: binary data in RenderBatch (#36221)

github-actions[bot] · uweigand · web-flow · commit 64aa83ef7070 · 2021-09-07T13:57:32.000-07:00
* Use little-endian accessors for RenderBatch binary data throughout * Fixes part 3 of #35709 Co-authored-by: Ulrich Weigand <ulrich.weigand@de.ibm.com>
diff --git a/src/Components/Ignitor/src/RenderBatchReader.cs b/src/Components/Ignitor/src/RenderBatchReader.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Buffers.Binary;
 using System.Text;
 
 #nullable enable
@@ -29,7 +30,7 @@ private static string[] ReadStringTable(ReadOnlySpan<byte> data, ReadOnlySpan<by
 
             for (var i = 0; i < indexes.Length; i += 4)
             {
-                var index = BitConverter.ToInt32(indexes.Slice(i, 4));
+                var index = BinaryPrimitives.ReadInt32LittleEndian(indexes.Slice(i, 4));
 
                 // The string table entries are all length-prefixed UTF8 blobs
                 var length = (int)ReadUnsignedLEB128(data, index, out var numLEB128Bytes);
@@ -46,21 +47,21 @@ private static ArrayRange<RenderTreeDiff> ReadUpdatedComponents(ReadOnlySpan<byt
 
             for (var i = 0; i < indexes.Length; i += 4)
             {
-                var index = BitConverter.ToInt32(indexes.Slice(i, 4));
+                var index = BinaryPrimitives.ReadInt32LittleEndian(indexes.Slice(i, 4));
 
-                var componentId = BitConverter.ToInt32(data.Slice(index, 4));
-                var editCount = BitConverter.ToInt32(data.Slice(index + 4, 4));
+                var componentId = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(index, 4));
+                var editCount = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(index + 4, 4));
 
                 var editData = data.Slice(index + 8);
                 var edits = new RenderTreeEdit[editCount];
                 for (var j = 0; j < editCount; j++)
                 {
-                    var type = (RenderTreeEditType)BitConverter.ToInt32(editData.Slice(0, 4));
-                    var siblingIndex = BitConverter.ToInt32(editData.Slice(4, 4));
+                    var type = (RenderTreeEditType)BinaryPrimitives.ReadInt32LittleEndian(editData.Slice(0, 4));
+                    var siblingIndex = BinaryPrimitives.ReadInt32LittleEndian(editData.Slice(4, 4));
 
                     // ReferenceFrameIndex and MoveToSiblingIndex share a slot, so this reads
                     // whichever one applies to the edit type
-                    var referenceFrameIndex = BitConverter.ToInt32(editData.Slice(8, 4));
+                    var referenceFrameIndex = BinaryPrimitives.ReadInt32LittleEndian(editData.Slice(8, 4));
                     var removedAttributeName = ReadString(editData.Slice(12, 4), strings);
 
                     editData = editData.Slice(16);
@@ -133,7 +134,7 @@ private static ArrayRange<RenderTreeFrame> ReadReferenceFrames(ReadOnlySpan<byte
             {
                 var frameData = data.Slice(i, ReferenceFrameSize);
 
-                var type = (RenderTreeFrameType)BitConverter.ToInt32(frameData.Slice(0, 4));
+                var type = (RenderTreeFrameType)BinaryPrimitives.ReadInt32LittleEndian(frameData.Slice(0, 4));
 
                 // We want each frame to take up the same number of bytes, so that the
                 // recipient can index into the array directly instead of having to
@@ -146,13 +147,13 @@ private static ArrayRange<RenderTreeFrame> ReadReferenceFrames(ReadOnlySpan<byte
                     case RenderTreeFrameType.Attribute:
                         var attributeName = ReadString(frameData.Slice(4, 4), strings);
                         var attributeValue = ReadString(frameData.Slice(8, 4), strings);
-                        var attributeEventHandlerId = BitConverter.ToUInt64(frameData.Slice(12, 8));
+                        var attributeEventHandlerId = BinaryPrimitives.ReadUInt64LittleEndian(frameData.Slice(12, 8));
                         result[i / ReferenceFrameSize] = RenderTreeFrame.Attribute(0, attributeName, attributeValue).WithAttributeEventHandlerId(attributeEventHandlerId);
                         break;
 
                     case RenderTreeFrameType.Component:
-                        var componentSubtreeLength = BitConverter.ToInt32(frameData.Slice(4, 4));
-                        var componentId = BitConverter.ToInt32(frameData.Slice(8, 4)); // Nowhere to put this without creating a ComponentState
+                        var componentSubtreeLength = BinaryPrimitives.ReadInt32LittleEndian(frameData.Slice(4, 4));
+                        var componentId = BinaryPrimitives.ReadInt32LittleEndian(frameData.Slice(8, 4)); // Nowhere to put this without creating a ComponentState
                         result[i / ReferenceFrameSize] = RenderTreeFrame.ChildComponent(0, componentType: null)
                             .WithComponentSubtreeLength(componentSubtreeLength)
                             .WithComponent(new ComponentState(componentId));
@@ -164,7 +165,7 @@ private static ArrayRange<RenderTreeFrame> ReadReferenceFrames(ReadOnlySpan<byte
                         break;
 
                     case RenderTreeFrameType.Element:
-                        var elementSubtreeLength = BitConverter.ToInt32(frameData.Slice(4, 4));
+                        var elementSubtreeLength = BinaryPrimitives.ReadInt32LittleEndian(frameData.Slice(4, 4));
                         var elementName = ReadString(frameData.Slice(8, 4), strings);
                         result[i / ReferenceFrameSize] = RenderTreeFrame.Element(0, elementName).WithElementSubtreeLength(elementSubtreeLength);
                         break;
@@ -176,7 +177,7 @@ private static ArrayRange<RenderTreeFrame> ReadReferenceFrames(ReadOnlySpan<byte
                         break;
 
                     case RenderTreeFrameType.Region:
-                        var regionSubtreeLength = BitConverter.ToInt32(frameData.Slice(4, 4));
+                        var regionSubtreeLength = BinaryPrimitives.ReadInt32LittleEndian(frameData.Slice(4, 4));
                         result[i / ReferenceFrameSize] = RenderTreeFrame.Region(0).WithRegionSubtreeLength(regionSubtreeLength);
                         break;
 
@@ -210,7 +211,7 @@ private static ArrayRange<ulong> ReadDisposedEventHandlerIds(ReadOnlySpan<byte>
 
         private static string? ReadString(ReadOnlySpan<byte> data, string[] strings)
         {
-            var index = BitConverter.ToInt32(data.Slice(0, 4));
+            var index = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(0, 4));
             return index >= 0 ? strings[index] : null;
         }
 
@@ -237,11 +238,11 @@ private readonly struct Sections
             public static Sections Parse(ReadOnlySpan<byte> data)
             {
                 return new Sections(
-                    BitConverter.ToInt32(data.Slice(data.Length - 20, 4)),
-                    BitConverter.ToInt32(data.Slice(data.Length - 16, 4)),
-                    BitConverter.ToInt32(data.Slice(data.Length - 12, 4)),
-                    BitConverter.ToInt32(data.Slice(data.Length - 8, 4)),
-                    BitConverter.ToInt32(data.Slice(data.Length - 4, 4)));
+                    BinaryPrimitives.ReadInt32LittleEndian(data.Slice(data.Length - 20, 4)),
+                    BinaryPrimitives.ReadInt32LittleEndian(data.Slice(data.Length - 16, 4)),
+                    BinaryPrimitives.ReadInt32LittleEndian(data.Slice(data.Length - 12, 4)),
+                    BinaryPrimitives.ReadInt32LittleEndian(data.Slice(data.Length - 8, 4)),
+                    BinaryPrimitives.ReadInt32LittleEndian(data.Slice(data.Length - 4, 4)));
             }
 
             private readonly int _updatedComponents;
@@ -262,14 +263,14 @@ public Sections(int updatedComponents, int referenceFrames, int disposedComponen
             public ReadOnlySpan<byte> GetUpdatedComponentIndexes(ReadOnlySpan<byte> data)
             {
                 // This is count-prefixed contiguous array of of integers.
-                var count = BitConverter.ToInt32(data.Slice(_updatedComponents, 4));
+                var count = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(_updatedComponents, 4));
                 return data.Slice(_updatedComponents + 4, count * 4);
             }
 
             public ReadOnlySpan<byte> GetReferenceFrameData(ReadOnlySpan<byte> data)
             {
                 // This is a count-prefixed contiguous array of RenderTreeFrame.
-                var count = BitConverter.ToInt32(data.Slice(_referenceFrames, 4));
+                var count = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(_referenceFrames, 4));
                 return data.Slice(_referenceFrames + 4, count * ReferenceFrameSize);
             }
 
diff --git a/src/Components/Ignitor/test/RenderBatchReaderTest.cs b/src/Components/Ignitor/test/RenderBatchReaderTest.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -232,7 +233,7 @@ static string[] ReadStringTable(Span<byte> data)
 
             // The string table position is given by the final int, and continues
             // until we get to the final set of top-level indices
-            var stringTableStartPosition = BitConverter.ToInt32(bytes, bytes.Length - 4);
+            var stringTableStartPosition = ReadInt(bytes, bytes.Length - 4);
             var stringTableEndPositionExcl = bytes.Length - 20;
 
             var result = new List<string>();
@@ -241,7 +242,7 @@ static string[] ReadStringTable(Span<byte> data)
                 entryPosition += 4)
             {
                 // The string table entries are all length-prefixed UTF8 blobs
-                var tableEntryPos = BitConverter.ToInt32(bytes, entryPosition);
+                var tableEntryPos = ReadInt(bytes, entryPosition);
                 var length = (int)ReadUnsignedLEB128(bytes, tableEntryPos, out var numLEB128Bytes);
                 var value = Encoding.UTF8.GetString(bytes, tableEntryPos + numLEB128Bytes, length);
                 result.Add(value);
@@ -299,7 +300,7 @@ static void AssertBinaryContents(Span<byte> data, int startIndex, params object[
         }
 
         static int ReadInt(Span<byte> bytes, int startOffset)
-            => BitConverter.ToInt32(bytes.Slice(startOffset, 4).ToArray(), 0);
+            => BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(startOffset, 4));
 
         public static uint ReadUnsignedLEB128(byte[] bytes, int startOffset, out int numBytesRead)
         {
diff --git a/src/Components/Server/test/Circuits/RenderBatchWriterTest.cs b/src/Components/Server/test/Circuits/RenderBatchWriterTest.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -283,7 +284,7 @@ static string[] ReadStringTable(Span<byte> data)
 
             // The string table position is given by the final int, and continues
             // until we get to the final set of top-level indices
-            var stringTableStartPosition = BitConverter.ToInt32(bytes, bytes.Length - 4);
+            var stringTableStartPosition = ReadInt(bytes, bytes.Length - 4);
             var stringTableEndPositionExcl = bytes.Length - 20;
 
             var result = new List<string>();
@@ -292,7 +293,7 @@ static string[] ReadStringTable(Span<byte> data)
                 entryPosition += 4)
             {
                 // The string table entries are all length-prefixed UTF8 blobs
-                var tableEntryPos = BitConverter.ToInt32(bytes, entryPosition);
+                var tableEntryPos = ReadInt(bytes, entryPosition);
                 var length = (int)ReadUnsignedLEB128(bytes, tableEntryPos, out var numLEB128Bytes);
                 var value = Encoding.UTF8.GetString(bytes, tableEntryPos + numLEB128Bytes, length);
                 result.Add(value);
@@ -350,7 +351,7 @@ static void AssertBinaryContents(Span<byte> data, int startIndex, params object[
         }
 
         static int ReadInt(Span<byte> bytes, int startOffset)
-            => BitConverter.ToInt32(bytes.Slice(startOffset, 4).ToArray(), 0);
+            => BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(startOffset, 4));
 
         public static uint ReadUnsignedLEB128(byte[] bytes, int startOffset, out int numBytesRead)
         {
