Refactor BaseIntrinsics to use pointers

src/NaCl.Core/Base/ChaCha20Base.cs

@@ -68,12 +68,9 @@ public override unsafe void ProcessStream(ReadOnlySpan<byte> nonce, Span<byte> o
         {
             Span<uint> state = stackalloc uint[BLOCK_SIZE_IN_INTS];
             SetInitialState(state, nonce, initialCounter);
-
-            fixed(uint* x = state)
-            fixed (byte* m = input, c = output.Slice(offset))
-            {
-                ChaCha20BaseIntrinsics.ChaCha20(x, m, c, (ulong)input.Length);
-            }
+            var c = output.Slice(offset);
+
+            ChaCha20BaseIntrinsics.ChaCha20(state, input, c, (ulong)input.Length);
         }
 #endif
 

src/NaCl.Core/Base/ChaCha20BaseIntrinsics.cs

@@ -10,26 +10,33 @@ namespace NaCl.Core.Base;
 public static class ChaCha20BaseIntrinsics
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void ChaCha20(uint* x, byte* m, byte* c, ulong bytes)
+    public static unsafe void ChaCha20(Span<uint> state, ReadOnlySpan<byte> input, Span<byte> output, ulong bytes)
     {
         if (!Sse3.IsSupported || !BitConverter.IsLittleEndian)
             throw new Exception("Error this vectorisation is not supported on this CPU");
 
-        if (Avx2.IsSupported && bytes >= 512)
+        fixed (uint* x = state)
+        fixed (byte* m_p = input, c_p = output)
         {
-            ChaCha512.Process(x, ref m, ref c, ref bytes);
-        }
-        if (bytes >= 256)
-        {
-            ChaCha256.Process(x, ref m, ref c, ref bytes);
-        }
-        while (bytes >= 64)
-        {
-            ChaCha64.Process64(x, ref m, ref c, ref bytes);
-        }
-        if (bytes > 0)
-        {
-            ChaCha64.ProcessVarLength(x, ref m, ref c, ref bytes);
+            var m = m_p;
+            var c = c_p;
+
+            if (Avx2.IsSupported && bytes >= 512)
+            {
+                ChaCha512.Process(x, ref m, ref c, ref bytes);
+            }
+            if (bytes >= 256)
+            {
+                ChaCha256.Process(x, ref m, ref c, ref bytes);
+            }
+            while (bytes >= 64)
+            {
+                ChaCha64.Process64(x, ref m, ref c, ref bytes);
+            }
+            if (bytes > 0)
+            {
+                ChaCha64.ProcessVarLength(x, ref m, ref c, ref bytes);
+            }
         }
     }
 
@@ -39,7 +46,11 @@ public static unsafe void HChaCha20(ReadOnlySpan<uint> state, Span<byte> subKey)
         if (!Sse3.IsSupported || !BitConverter.IsLittleEndian)
             throw new Exception("Error this vectorisation is not supported on this CPU");
 
-        ChaCha64.HChaCha20(state, subKey);
+        fixed (uint* x = state)
+        fixed (byte* sk = subKey)
+        {
+            ChaCha64.HChaCha20(x, sk);
+        }
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -48,7 +59,11 @@ public static unsafe void ChaCha20KeyStream(ReadOnlySpan<uint> state, Span<byte>
         if (!Sse3.IsSupported || !BitConverter.IsLittleEndian)
             throw new Exception("Error this vectorisation is not supported on this CPU");
 
-        ChaCha64.KeyStream64(state, output);
+        fixed (byte* c = output)
+        fixed (uint* x = state)
+        {
+            ChaCha64.KeyStream64(x, c);
+        }
     }
 }
 #endif

src/NaCl.Core/Base/ChaChaIntrinsics/ChaCha64.cs

@@ -94,51 +94,43 @@ public static unsafe void ProcessVarLength(uint* x, ref byte* m, ref byte* c, re
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void HChaCha20(ReadOnlySpan<uint> state, Span<byte> subKey)
+    public static unsafe void HChaCha20(uint* x, byte* sk)
     {
-        fixed(uint* x = state)
-        fixed(byte* sk = subKey)
-        {
-            Vector128<uint> x_0 = Sse2.LoadVector128(x);
-            Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
-            Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
-            Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
+        Vector128<uint> x_0 = Sse2.LoadVector128(x);
+        Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
+        Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
+        Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
 
-            ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
+        ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
 
-            Sse2.Store(sk, Vector128.AsByte(x_0));
-            Sse2.Store(sk + 16, Vector128.AsByte(x_3));
-        }
+        Sse2.Store(sk, Vector128.AsByte(x_0));
+        Sse2.Store(sk + 16, Vector128.AsByte(x_3));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void KeyStream64(ReadOnlySpan<uint> state, Span<byte> output)
+    public static unsafe void KeyStream64(uint* x, byte* c)
     {
-        fixed (byte* k = output)
-        fixed (uint* x = state)
-        {
-            Vector128<uint> x_0 = Sse2.LoadVector128(x);
-            Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
-            Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
-            Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
-
-            Vector128<uint> orig_0 = x_0;
-            Vector128<uint> orig_1 = x_1;
-            Vector128<uint> orig_2 = x_2;
-            Vector128<uint> orig_3 = x_3;
-
-            ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
-
-            x_0 = Sse2.Add(x_0, orig_0);
-            x_1 = Sse2.Add(x_1, orig_1);
-            x_2 = Sse2.Add(x_2, orig_2);
-            x_3 = Sse2.Add(x_3, orig_3);
-
-            Sse2.Store(k, x_0.AsByte());
-            Sse2.Store(k + 16, x_1.AsByte());
-            Sse2.Store(k + 32, x_2.AsByte());
-            Sse2.Store(k + 48, x_3.AsByte());
-        }
+        Vector128<uint> x_0 = Sse2.LoadVector128(x);
+        Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
+        Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
+        Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
+
+        Vector128<uint> orig_0 = x_0;
+        Vector128<uint> orig_1 = x_1;
+        Vector128<uint> orig_2 = x_2;
+        Vector128<uint> orig_3 = x_3;
+
+        ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
+
+        x_0 = Sse2.Add(x_0, orig_0);
+        x_1 = Sse2.Add(x_1, orig_1);
+        x_2 = Sse2.Add(x_2, orig_2);
+        x_3 = Sse2.Add(x_3, orig_3);
+
+        Sse2.Store(c, x_0.AsByte());
+        Sse2.Store(c + 16, x_1.AsByte());
+        Sse2.Store(c + 32, x_2.AsByte());
+        Sse2.Store(c + 48, x_3.AsByte());
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/NaCl.Core/Base/Salsa20Base.cs

@@ -67,11 +67,9 @@ public override unsafe void ProcessStream(ReadOnlySpan<byte> nonce, Span<byte> o
         {
             Span<uint> state = stackalloc uint[BLOCK_SIZE_IN_INTS];
             SetInitialState(state, nonce, initialCounter);
-            fixed (uint* x = state)
-            fixed (byte* m = input, c = output.Slice(offset))
-            {
-                Salsa20BaseIntrinsics.Salsa20(x, m, c, (ulong)input.Length);
-            }
+            var c = output.Slice(offset);
+
+            Salsa20BaseIntrinsics.Salsa20(state, input, c, (ulong)input.Length);
         }
 #endif
 

src/NaCl.Core/Base/Salsa20BaseIntrinsics.cs

@@ -10,26 +10,33 @@ namespace NaCl.Core.Base;
 public static class Salsa20BaseIntrinsics
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void Salsa20(uint* x, byte* m, byte* c, ulong bytes)
+    public static unsafe void Salsa20(Span<uint> state, ReadOnlySpan<byte> input, Span<byte> output, ulong bytes)
     {
         if (!Sse3.IsSupported || !BitConverter.IsLittleEndian)
             throw new Exception("Error this vectorisation is not supported on this CPU");
 
-        if (Avx2.IsSupported && bytes >= 512)
+        fixed (uint* x = state)
+        fixed (byte* m_p = input, c_p = output)
         {
-            Salsa512.Process(x, ref m, ref c, ref bytes);
-        }
-        if (bytes >= 256)
-        {
-            Salsa256.Process(x, ref m, ref c, ref bytes);
-        }
-        while (bytes >= 64)
-        {
-            Salsa64.Process64(x, ref m, ref c, ref bytes);
-        }
-        if (bytes > 0)
-        {
-            Salsa64.ProcessVarLength(x, ref m, ref c, ref bytes);
+            var m = m_p;
+            var c = c_p;
+
+            if (Avx2.IsSupported && bytes >= 512)
+            {
+                Salsa512.Process(x, ref m, ref c, ref bytes);
+            }
+            if (bytes >= 256)
+            {
+                Salsa256.Process(x, ref m, ref c, ref bytes);
+            }
+            while (bytes >= 64)
+            {
+                Salsa64.Process64(x, ref m, ref c, ref bytes);
+            }
+            if (bytes > 0)
+            {
+                Salsa64.ProcessVarLength(x, ref m, ref c, ref bytes);
+            }
         }
     }
 
@@ -39,7 +46,11 @@ public static unsafe void HSalsa20(ReadOnlySpan<uint> state, Span<byte> subKey)
         if (!Sse3.IsSupported || !BitConverter.IsLittleEndian)
             throw new Exception("Error this vectorisation is not supported on this CPU");
 
-        Salsa64.HSalsa20(state, subKey);
+        fixed (uint* x = state)
+        fixed (byte* sk = subKey)
+        {
+            Salsa64.HSalsa20(x, sk);
+        }
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -48,7 +59,11 @@ public static unsafe void Salsa20KeyStream(ReadOnlySpan<uint> state, Span<byte>
         if (!Sse3.IsSupported || !BitConverter.IsLittleEndian)
             throw new Exception("Error this vectorisation is not supported on this CPU");
 
-        Salsa64.KeyStream64(state, output);
+        fixed (byte* c = output)
+        fixed (uint* x = state)
+        {
+            Salsa64.KeyStream64(x, c);
+        }
     }
 }
 #endif

src/NaCl.Core/Base/SalsaIntrinsics/Salsa64.cs

@@ -94,59 +94,51 @@ public static unsafe void ProcessVarLength(uint* x, ref byte* m, ref byte* c, re
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void HSalsa20(ReadOnlySpan<uint> state, Span<byte> subKey)
+    public static unsafe void HSalsa20(uint* x, byte* sk)
     {
-        fixed (uint* x = state)
-        fixed (byte* sk = subKey)
-        {
-            Vector128<uint> x_0 = Sse2.LoadVector128(x);
-            Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
-            Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
-            Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
+        Vector128<uint> x_0 = Sse2.LoadVector128(x);
+        Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
+        Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
+        Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
 
-            ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
+        ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
 
-            // HSalsa returns a 32 byte array of 0,5,10,15,6,7,8,9
+        // HSalsa returns a 32 byte array of 0,5,10,15,6,7,8,9
 
-            // <0, 5, 2, 3> + <8, 9, 10, 15> -> <0, 5, 10, 15>
-            var t_0 = GetDiagonal(x_0, x_1, x_2, x_3);
+        // <0, 5, 2, 3> + <8, 9, 10, 15> -> <0, 5, 10, 15>
+        var t_0 = GetDiagonal(x_0, x_1, x_2, x_3);
 
-            // Get <4, 5, 6, 7> & <8, 9, 10, 11> then unpack halves for <6, 7, 8, 9>
-            var t_1 = UnpackHighLow(x_1, x_2);
+        // Get <4, 5, 6, 7> & <8, 9, 10, 11> then unpack halves for <6, 7, 8, 9>
+        var t_1 = UnpackHighLow(x_1, x_2);
 
-            Sse2.Store(sk, Vector128.AsByte(t_0));
-            Sse2.Store(sk + 16, Vector128.AsByte(t_1));
-        }
+        Sse2.Store(sk, Vector128.AsByte(t_0));
+        Sse2.Store(sk + 16, Vector128.AsByte(t_1));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void KeyStream64(ReadOnlySpan<uint> state, Span<byte> output)
+    public static unsafe void KeyStream64(uint* x, byte* c)
     {
-        fixed (byte* k = output)
-        fixed (uint* x = state)
-        {
-            Vector128<uint> x_0 = Sse2.LoadVector128(x);
-            Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
-            Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
-            Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
-
-            Vector128<uint> orig_0 = x_0;
-            Vector128<uint> orig_1 = x_1;
-            Vector128<uint> orig_2 = x_2;
-            Vector128<uint> orig_3 = x_3;
-
-            ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
-
-            x_0 = Sse2.Add(x_0, orig_0);
-            x_1 = Sse2.Add(x_1, orig_1);
-            x_2 = Sse2.Add(x_2, orig_2);
-            x_3 = Sse2.Add(x_3, orig_3);
-
-            Sse2.Store(k, x_0.AsByte());
-            Sse2.Store(k + 16, x_1.AsByte());
-            Sse2.Store(k + 32, x_2.AsByte());
-            Sse2.Store(k + 48, x_3.AsByte());
-        }
+        Vector128<uint> x_0 = Sse2.LoadVector128(x);
+        Vector128<uint> x_1 = Sse2.LoadVector128(x + 4);
+        Vector128<uint> x_2 = Sse2.LoadVector128(x + 8);
+        Vector128<uint> x_3 = Sse2.LoadVector128(x + 12);
+
+        Vector128<uint> orig_0 = x_0;
+        Vector128<uint> orig_1 = x_1;
+        Vector128<uint> orig_2 = x_2;
+        Vector128<uint> orig_3 = x_3;
+
+        ShuffleState(ref x_0, ref x_1, ref x_2, ref x_3);
+
+        x_0 = Sse2.Add(x_0, orig_0);
+        x_1 = Sse2.Add(x_1, orig_1);
+        x_2 = Sse2.Add(x_2, orig_2);
+        x_3 = Sse2.Add(x_3, orig_3);
+
+        Sse2.Store(c, x_0.AsByte());
+        Sse2.Store(c + 16, x_1.AsByte());
+        Sse2.Store(c + 32, x_2.AsByte());
+        Sse2.Store(c + 48, x_3.AsByte());
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]