feat(crypto): ✨ add Sha256 and X25519 APIs, and use Span based APIs

Author: jasonboukheir

Runtime/Algorand.Unity.Crypto/ChaCha20Poly1305/ChaCha20Poly1305+Decrypt.cs

@@ -1,6 +1,4 @@
-using Algorand.Unity.LowLevel;
-using Unity.Collections;
-using Unity.Collections.LowLevel.Unsafe;
+using System;
 
 namespace Algorand.Unity.Crypto
 {
@@ -9,31 +7,39 @@ public static partial class ChaCha20Poly1305
         public enum DecryptionError
         {
             None = 0,
-            VerificationFailed = -1
+            VerificationFailed = -1,
+            InvalidMessageLength = 1
         }
 
-        public static unsafe DecryptionError Decrypt<TCipher>(
-            NativeList<byte> message,
-            TCipher cipher,
+        public static unsafe DecryptionError Decrypt(
+            Span<byte> message,
+            ReadOnlySpan<byte> cipher,
             Key key,
             Nonce nonce
         )
-            where TCipher : struct, IByteArray
         {
-            message.Length = cipher.Length - AuthTag.Size;
-            var errorCode = sodium.crypto_aead_chacha20poly1305_ietf_decrypt(
-                message.GetUnsafePtr(),
-                out var messageLength,
-                null,
-                cipher.GetUnsafePtr(),
-                (ulong)cipher.Length,
-                null,
-                0,
-                nonce.GetUnsafePtr(),
-                key.GetUnsafePtr()
-            );
-            message.Length = (int)messageLength;
+            if (message.Length != cipher.Length - AuthTag.Size)
+            {
+                return DecryptionError.InvalidMessageLength;
+            }
+
+            var errorCode = 0;
+            fixed (byte* m = &message[0])
+            fixed (byte* c = &cipher[0])
+            {
+                errorCode = sodium.crypto_aead_chacha20poly1305_ietf_decrypt(
+                    m,
+                    out _,
+                    null,
+                    c,
+                    (ulong)cipher.Length,
+                    null,
+                    0,
+                    nonce.GetUnsafePtr(),
+                    key.GetUnsafePtr()
+                );
+            }
             return (DecryptionError)errorCode;
         }
     }
-}
+}

Runtime/Algorand.Unity.Crypto/ChaCha20Poly1305/ChaCha20Poly1305+Encrypt.cs

@@ -1,39 +1,53 @@
-using Algorand.Unity.LowLevel;
-using Unity.Collections;
-using Unity.Collections.LowLevel.Unsafe;
+using System;
 
 namespace Algorand.Unity.Crypto
 {
     public static partial class ChaCha20Poly1305
     {
         public enum EncryptionError
         {
-            None = 0
+            None = 0,
+            CipherInvalidSize = 1,
         }
 
-        public static unsafe EncryptionError Encrypt<TMessage>(
-            NativeList<byte> cipher,
-            TMessage message,
+        /// <summary>
+        /// Encrypt a message using the ChaCha20Poly1305 algorithm.
+        /// </summary>
+        /// <param name="cipher">The encrypted message.</param>
+        /// <param name="message">The message to encrypt.</param>
+        /// <param name="key">The symmetric key to encrypt with.</param>
+        /// <param name="nonce">The 12 byte iv to use to encrypt.</param>
+        /// <returns></returns>
+        public static unsafe EncryptionError Encrypt(
+            Span<byte> cipher,
+            ReadOnlySpan<byte> message,
             Key key,
             Nonce nonce
         )
-            where TMessage : struct, IByteArray
         {
-            cipher.Length = message.Length + AuthTag.Size;
-            var errorCode = sodium.crypto_aead_chacha20poly1305_ietf_encrypt(
-                cipher.GetUnsafePtr(),
-                out var cipherLength,
-                message.GetUnsafePtr(),
-                (ulong)message.Length,
-                null,
-                0,
-                null,
-                nonce.GetUnsafePtr(),
-                key.GetUnsafePtr()
-            );
-            cipher.Length = (int)cipherLength;
-            nonce += 1;
+            var cipherLength = message.Length + AuthTag.Size;
+            if (cipher.Length != cipherLength)
+            {
+                return EncryptionError.CipherInvalidSize;
+            }
+            var errorCode = default(int);
+
+            fixed (byte* c = &cipher[0])
+            fixed (byte* m = &message[0])
+            {
+                errorCode = sodium.crypto_aead_chacha20poly1305_ietf_encrypt(
+                    c,
+                    out _,
+                    m,
+                    (ulong)message.Length,
+                    null,
+                    0,
+                    null,
+                    nonce.GetUnsafePtr(),
+                    key.GetUnsafePtr()
+                );
+            }
             return (EncryptionError)errorCode;
         }
     }
-}
+}

Runtime/Algorand.Unity.Crypto/Ed25519/Ed25519+SecretKeyHandle.cs

@@ -56,6 +56,22 @@ public readonly unsafe Signature Sign<TMessage>(TMessage message)
                     Ptr);
                 return signature;
             }
+
+            public readonly unsafe Signature Sign(ReadOnlySpan<byte> message)
+            {
+                var signature = new Signature();
+                fixed (byte* mPtr = &message.GetPinnableReference())
+                {
+                    crypto_sign_ed25519_detached(
+                        &signature,
+                        out _,
+                        mPtr,
+                        (ulong)message.Length,
+                        Ptr);
+                }
+
+                return signature;
+            }
         }
     }
 }

Runtime/Algorand.Unity.Crypto/Ed25519/Ed25519+Signature.cs

@@ -55,6 +55,23 @@ public bool Verify<TMessage>(TMessage message, PublicKey pk)
                 }
             }
 
+            public bool Verify(ReadOnlySpan<byte> message, PublicKey pk)
+            {
+                unsafe
+                {
+                    fixed (byte* m = message)
+                    fixed (Signature* s = &this)
+                    {
+                        var error = crypto_sign_ed25519_verify_detached(
+                            s,
+                            m,
+                            (ulong)message.Length,
+                            &pk);
+                        return error == 0;
+                    }
+                }
+            }
+
             public override bool Equals(object obj)
             {
                 return ByteArray.Equals(this, obj);

Runtime/Algorand.Unity.Crypto/Interop/sodium/sodium.ChaCha20Poly1305.cs renamed to Runtime/Algorand.Unity.Crypto/Interop/sodium/sodium+ChaCha20Poly1305.cs

@@ -0,0 +1,31 @@
+using System.Runtime.InteropServices;
+
+namespace Algorand.Unity.Crypto
+{
+    internal static unsafe partial class sodium
+    {
+        internal const ulong crypto_box_PUBLICKEYBYTES = 32U;
+        internal const ulong crypto_box_SECRETKEYBYTES = 32U;
+        internal const ulong crypto_box_NONCEBYTES = 24U;
+
+        [DllImport(Library, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int crypto_box_keypair(
+            void* pk,
+            void* sk);
+
+        [DllImport(Library, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int crypto_box_seed_keypair(
+            void* pk,
+            void* sk,
+            void* seed);
+
+        [DllImport(Library, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int crypto_box_easy(
+            void* c,
+            void* m,
+            ulong mlen,
+            void* n,
+            void* pk,
+            void* sk);
+    }
+}