Use ReadOnlySpan in places

4 files changed, 44 insertions, 42 deletions

diff --git a/crypto/src/crypto/Check.cs b/crypto/src/crypto/Check.cs
index 81d07e23c..36263dc24 100644
--- a/crypto/src/crypto/Check.cs
+++ b/crypto/src/crypto/Check.cs
@@ -23,7 +23,7 @@ namespace Org.BouncyCastle.Crypto
         }
 
 #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-        internal static void DataLength(Span<byte> input, int len, string msg)
+        internal static void DataLength(ReadOnlySpan<byte> input, int len, string msg)
         {
             if (input.Length < len)
                 throw new DataLengthException(msg);
diff --git a/crypto/src/crypto/engines/AesX86Engine.cs b/crypto/src/crypto/engines/AesX86Engine.cs
index a7dcfc686..a270c2ad2 100644
--- a/crypto/src/crypto/engines/AesX86Engine.cs
+++ b/crypto/src/crypto/engines/AesX86Engine.cs
@@ -190,7 +190,7 @@ namespace Org.BouncyCastle.Crypto.Engines
             return 16;
         }
 
-        public int ProcessBlock(Span<byte> input, Span<byte> output)
+        public int ProcessBlock(ReadOnlySpan<byte> input, Span<byte> output)
         {
             Check.DataLength(input, 16, "input buffer too short");
             Check.OutputLength(output, 16, "output buffer too short");
@@ -329,13 +329,13 @@ namespace Org.BouncyCastle.Crypto.Engines
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<byte> Load128(Span<byte> t)
+        private static Vector128<byte> Load128(ReadOnlySpan<byte> t)
         {
 #if NET7_0_OR_GREATER
             return Vector128.Create<byte>(t);
 #else
             if (BitConverter.IsLittleEndian && Unsafe.SizeOf<Vector128<byte>>() == 16)
-                return Unsafe.ReadUnaligned<Vector128<byte>>(ref t[0]);
+                return Unsafe.ReadUnaligned<Vector128<byte>>(ref Unsafe.AsRef(t[0]));
 
             return Vector128.Create(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11], t[12],
                 t[13], t[14], t[15]);
@@ -343,13 +343,13 @@ namespace Org.BouncyCastle.Crypto.Engines
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector64<byte> Load64(Span<byte> t)
+        private static Vector64<byte> Load64(ReadOnlySpan<byte> t)
         {
 #if NET7_0_OR_GREATER
             return Vector64.Create<byte>(t);
 #else
             if (BitConverter.IsLittleEndian && Unsafe.SizeOf<Vector64<byte>>() == 8)
-                return Unsafe.ReadUnaligned<Vector64<byte>>(ref t[0]);
+                return Unsafe.ReadUnaligned<Vector64<byte>>(ref Unsafe.AsRef(t[0]));
 
             return Vector64.Create(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7]);
 #endif
@@ -369,7 +369,7 @@ namespace Org.BouncyCastle.Crypto.Engines
 
             var u = s.AsUInt64();
             Utilities.Pack.UInt64_To_LE(u.GetElement(0), t);
-            Utilities.Pack.UInt64_To_LE(u.GetElement(1), t.Slice(8));
+            Utilities.Pack.UInt64_To_LE(u.GetElement(1), t[8..]);
 #endif
         }
     }
diff --git a/crypto/src/crypto/engines/ChaCha7539Engine.cs b/crypto/src/crypto/engines/ChaCha7539Engine.cs
index 81e97478b..d1dd9755b 100644
--- a/crypto/src/crypto/engines/ChaCha7539Engine.cs
+++ b/crypto/src/crypto/engines/ChaCha7539Engine.cs
@@ -168,7 +168,8 @@ namespace Org.BouncyCastle.Crypto.Engines
 
 #if NETCOREAPP3_0_OR_GREATER
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		internal static void ImplProcessBlocks2_X86_Avx2(int rounds, uint[] state, Span<byte> input, Span<byte> output)
+		internal static void ImplProcessBlocks2_X86_Avx2(int rounds, uint[] state, ReadOnlySpan<byte> input,
+			Span<byte> output)
 		{
 			if (!Avx2.IsSupported)
 				throw new PlatformNotSupportedException();
@@ -244,18 +245,19 @@ namespace Org.BouncyCastle.Crypto.Engines
 			var n3 = Avx2.Permute2x128(v2, v3, 0x31).AsByte();
 
 			n0 = Avx2.Xor(n0, Load256_Byte(input));
-			n1 = Avx2.Xor(n1, Load256_Byte(input.Slice(0x20)));
-			n2 = Avx2.Xor(n2, Load256_Byte(input.Slice(0x40)));
-			n3 = Avx2.Xor(n3, Load256_Byte(input.Slice(0x60)));
+			n1 = Avx2.Xor(n1, Load256_Byte(input[0x20..]));
+			n2 = Avx2.Xor(n2, Load256_Byte(input[0x40..]));
+			n3 = Avx2.Xor(n3, Load256_Byte(input[0x60..]));
 
 			Store256_Byte(ref n0, output);
-			Store256_Byte(ref n1, output.Slice(0x20));
-			Store256_Byte(ref n2, output.Slice(0x40));
-			Store256_Byte(ref n3, output.Slice(0x60));
+			Store256_Byte(ref n1, output[0x20..]);
+			Store256_Byte(ref n2, output[0x40..]);
+			Store256_Byte(ref n3, output[0x60..]);
 		}
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-		internal static void ImplProcessBlocks2_X86_Sse2(int rounds, uint[] state, Span<byte> input, Span<byte> output)
+		internal static void ImplProcessBlocks2_X86_Sse2(int rounds, uint[] state, ReadOnlySpan<byte> input,
+			Span<byte> output)
 		{
 			if (!Sse2.IsSupported)
 				throw new PlatformNotSupportedException();
@@ -319,9 +321,9 @@ namespace Org.BouncyCastle.Crypto.Engines
 			v3 = Sse2.Add(v3, x3);
 
 			var n0 = Load128_Byte(input);
-			var n1 = Load128_Byte(input.Slice(0x10));
-			var n2 = Load128_Byte(input.Slice(0x20));
-			var n3 = Load128_Byte(input.Slice(0x30));
+			var n1 = Load128_Byte(input[0x10..]);
+			var n2 = Load128_Byte(input[0x20..]);
+			var n3 = Load128_Byte(input[0x30..]);
 
 			n0 = Sse2.Xor(n0, v0.AsByte());
 			n1 = Sse2.Xor(n1, v1.AsByte());
@@ -329,9 +331,9 @@ namespace Org.BouncyCastle.Crypto.Engines
 			n3 = Sse2.Xor(n3, v3.AsByte());
 
 			Store128_Byte(ref n0, output);
-			Store128_Byte(ref n1, output.Slice(0x10));
-			Store128_Byte(ref n2, output.Slice(0x20));
-			Store128_Byte(ref n3, output.Slice(0x30));
+			Store128_Byte(ref n1, output[0x10..]);
+			Store128_Byte(ref n2, output[0x20..]);
+			Store128_Byte(ref n3, output[0x30..]);
 
 			x3 = Load128_UInt32(state.AsSpan(12));
 			++state[12];
@@ -383,46 +385,46 @@ namespace Org.BouncyCastle.Crypto.Engines
 			v2 = Sse2.Add(v2, x2);
 			v3 = Sse2.Add(v3, x3);
 
-			n0 = Load128_Byte(input.Slice(0x40));
-			n1 = Load128_Byte(input.Slice(0x50));
-			n2 = Load128_Byte(input.Slice(0x60));
-			n3 = Load128_Byte(input.Slice(0x70));
+			n0 = Load128_Byte(input[0x40..]);
+			n1 = Load128_Byte(input[0x50..]);
+			n2 = Load128_Byte(input[0x60..]);
+			n3 = Load128_Byte(input[0x70..]);
 
 			n0 = Sse2.Xor(n0, v0.AsByte());
 			n1 = Sse2.Xor(n1, v1.AsByte());
 			n2 = Sse2.Xor(n2, v2.AsByte());
 			n3 = Sse2.Xor(n3, v3.AsByte());
 
-			Store128_Byte(ref n0, output.Slice(0x40));
-			Store128_Byte(ref n1, output.Slice(0x50));
-			Store128_Byte(ref n2, output.Slice(0x60));
-			Store128_Byte(ref n3, output.Slice(0x70));
+			Store128_Byte(ref n0, output[0x40..]);
+			Store128_Byte(ref n1, output[0x50..]);
+			Store128_Byte(ref n2, output[0x60..]);
+			Store128_Byte(ref n3, output[0x70..]);
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static Vector128<byte> Load128_Byte(Span<byte> t)
+		private static Vector128<byte> Load128_Byte(ReadOnlySpan<byte> t)
 		{
 			if (BitConverter.IsLittleEndian && Unsafe.SizeOf<Vector128<byte>>() == 16)
-				return Unsafe.ReadUnaligned<Vector128<byte>>(ref t[0]);
+				return Unsafe.ReadUnaligned<Vector128<byte>>(ref Unsafe.AsRef(t[0]));
 
 			return Vector128.Create(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11], t[12],
 				t[13], t[14], t[15]);
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static Vector128<uint> Load128_UInt32(Span<uint> t)
+		private static Vector128<uint> Load128_UInt32(ReadOnlySpan<uint> t)
 		{
 			if (BitConverter.IsLittleEndian && Unsafe.SizeOf<Vector128<uint>>() == 16)
-				return Unsafe.ReadUnaligned<Vector128<uint>>(ref Unsafe.As<uint, byte>(ref t[0]));
+				return Unsafe.ReadUnaligned<Vector128<uint>>(ref Unsafe.As<uint, byte>(ref Unsafe.AsRef(t[0])));
 
 			return Vector128.Create(t[0], t[1], t[2], t[3]);
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static Vector256<byte> Load256_Byte(Span<byte> t)
+		private static Vector256<byte> Load256_Byte(ReadOnlySpan<byte> t)
         {
 			if (BitConverter.IsLittleEndian && Unsafe.SizeOf<Vector256<byte>>() == 32)
-				return Unsafe.ReadUnaligned<Vector256<byte>>(ref t[0]);
+				return Unsafe.ReadUnaligned<Vector256<byte>>(ref Unsafe.AsRef(t[0]));
 
 			return Vector256.Create(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11], t[12],
 				t[13], t[14], t[15], t[16], t[17], t[18], t[19], t[20], t[21], t[22], t[23], t[24], t[25], t[26], t[27],
@@ -440,7 +442,7 @@ namespace Org.BouncyCastle.Crypto.Engines
 
 			var u = s.AsUInt64();
 			Pack.UInt64_To_LE(u.GetElement(0), t);
-			Pack.UInt64_To_LE(u.GetElement(1), t.Slice(8));
+			Pack.UInt64_To_LE(u.GetElement(1), t[8..]);
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -454,9 +456,9 @@ namespace Org.BouncyCastle.Crypto.Engines
 
 			var u = s.AsUInt64();
 			Pack.UInt64_To_LE(u.GetElement(0), t);
-			Pack.UInt64_To_LE(u.GetElement(1), t.Slice(8));
-			Pack.UInt64_To_LE(u.GetElement(2), t.Slice(16));
-			Pack.UInt64_To_LE(u.GetElement(3), t.Slice(24));
+			Pack.UInt64_To_LE(u.GetElement(1), t[8..]);
+			Pack.UInt64_To_LE(u.GetElement(2), t[16..]);
+			Pack.UInt64_To_LE(u.GetElement(3), t[24..]);
 		}
 #endif
 	}
diff --git a/crypto/src/crypto/engines/ChaChaEngine.cs b/crypto/src/crypto/engines/ChaChaEngine.cs
index a16491ba0..646a6976c 100644
--- a/crypto/src/crypto/engines/ChaChaEngine.cs
+++ b/crypto/src/crypto/engines/ChaChaEngine.cs
@@ -213,10 +213,10 @@ namespace Org.BouncyCastle.Crypto.Engines
 
 #if NETCOREAPP3_0_OR_GREATER
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static Vector128<uint> Load128_UInt32(Span<uint> t)
+		private static Vector128<uint> Load128_UInt32(ReadOnlySpan<uint> t)
 		{
 			if (BitConverter.IsLittleEndian && Unsafe.SizeOf<Vector128<uint>>() == 16)
-				return Unsafe.ReadUnaligned<Vector128<uint>>(ref Unsafe.As<uint, byte>(ref t[0]));
+				return Unsafe.ReadUnaligned<Vector128<uint>>(ref Unsafe.As<uint, byte>(ref Unsafe.AsRef(t[0])));
 
 			return Vector128.Create(t[0], t[1], t[2], t[3]);
 		}
@@ -232,7 +232,7 @@ namespace Org.BouncyCastle.Crypto.Engines
 
 			var u = s.AsUInt64();
 			Pack.UInt64_To_LE(u.GetElement(0), t);
-			Pack.UInt64_To_LE(u.GetElement(1), t.Slice(8));
+			Pack.UInt64_To_LE(u.GetElement(1), t[8..]);
 		}
 #endif
 	}