Blake2B support.

SpaceWizards.Sodium/CryptoGenericHashBlake2B.cs

@@ -0,0 +1,202 @@
+using SpaceWizards.Sodium.Interop;
+
+namespace SpaceWizards.Sodium;
+
+using static Interop.Libsodium;
+
+/// <summary>
+/// Wrappers around the <c>crypto_generichash_blake2b_</c> APIs.
+/// </summary>
+public static class CryptoGenericHashBlake2B
+{
+    static CryptoGenericHashBlake2B()
+    {
+        SodiumCore.EnsureInit();
+    }
+
+    public const int BytesMin = (int)crypto_generichash_blake2b_BYTES_MIN;
+    public const int BytesMax = (int)crypto_generichash_blake2b_BYTES_MAX;
+    public const int Bytes = (int)crypto_generichash_blake2b_BYTES;
+
+    public const int KeyBytesMin = (int)crypto_generichash_blake2b_KEYBYTES_MIN;
+    public const int KeyBytesMax = (int)crypto_generichash_blake2b_KEYBYTES_MAX;
+    public const int KeyBytes = (int)crypto_generichash_blake2b_BYTES;
+
+    public const int SaltBytes = (int)crypto_generichash_blake2b_SALTBYTES;
+    public const int PersonalBytes = (int)crypto_generichash_blake2b_PERSONALBYTES;
+
+    public static unsafe void Keygen(Span<byte> key)
+    {
+        if (key.Length != KeyBytes)
+            throw new ArgumentException($"Key must be {nameof(KeyBytes)} bytes");
+
+        fixed (byte* k = key)
+        {
+            crypto_generichash_blake2b_keygen(k);
+        }
+    }
+
+    public static byte[] Keygen()
+    {
+        var key = new byte[KeyBytes];
+        Keygen(key);
+        return key;
+    }
+
+    public static byte[] Hash(
+        int outputLength,
+        ReadOnlySpan<byte> input,
+        ReadOnlySpan<byte> key)
+    {
+        var output = new byte[outputLength];
+
+        Hash(output, input, key);
+
+        return output;
+    }
+
+    public static unsafe bool Hash(Span<byte> output, ReadOnlySpan<byte> input, ReadOnlySpan<byte> key)
+    {
+        if (key.Length > KeyBytesMax)
+            throw new ArgumentException("Key too large");
+
+        if (output.Length is < BytesMin or > BytesMax)
+            throw new ArgumentException("Output is invalid size");
+
+        fixed (byte* i = input)
+        fixed (byte* o = output)
+        fixed (byte* k = key)
+        {
+            var ret = crypto_generichash_blake2b(
+                o, (nuint)output.Length,
+                i, (ulong)input.Length,
+                k, (nuint)key.Length);
+
+            return ret == 0;
+        }
+    }
+
+    public static byte[] HashSaltPersonal(
+        int outputLength,
+        ReadOnlySpan<byte> input,
+        ReadOnlySpan<byte> key,
+        ReadOnlySpan<byte> salt,
+        ReadOnlySpan<byte> personal)
+    {
+        var output = new byte[outputLength];
+
+        HashSaltPersonal(output, input, key, salt, personal);
+
+        return output;
+    }
+
+
+    public static unsafe bool HashSaltPersonal(
+        Span<byte> output,
+        ReadOnlySpan<byte> input,
+        ReadOnlySpan<byte> key,
+        ReadOnlySpan<byte> salt,
+        ReadOnlySpan<byte> personal)
+    {
+        if (key.Length > KeyBytesMax)
+            throw new ArgumentException("Key too large");
+
+        if (output.Length is < BytesMin or > BytesMax)
+            throw new ArgumentException("Output is invalid size");
+
+        if (salt.Length != SaltBytes && salt.Length != 0)
+            throw new ArgumentException($"Salt must be {nameof(SaltBytes)} bytes or empty");
+
+        if (personal.Length != PersonalBytes && personal.Length != 0)
+            throw new ArgumentException($"Personalization must be {nameof(PersonalBytes)} bytes or empty");
+
+        fixed (byte* i = input)
+        fixed (byte* o = output)
+        fixed (byte* k = key)
+        fixed (byte* s = salt)
+        fixed (byte* p = personal)
+        {
+            var ret = crypto_generichash_blake2b_salt_personal(
+                o, (nuint)output.Length,
+                i, (ulong)input.Length,
+                k, (nuint)key.Length,
+                s,
+                p);
+
+            return ret == 0;
+        }
+    }
+
+    public static unsafe bool Init(ref State state, ReadOnlySpan<byte> key, int outputLength)
+    {
+        if (key.Length > KeyBytesMax)
+            throw new ArgumentException("Key too large");
+
+        if (outputLength is < BytesMin or > BytesMax)
+            throw new ArgumentException("Output is invalid size");
+
+        fixed (crypto_generichash_blake2b_state* s = &state.Data)
+        fixed (byte* k = key)
+        {
+            var ret = crypto_generichash_blake2b_init(s, k, (nuint)key.Length, (nuint)outputLength);
+            return ret == 0;
+        }
+    }
+
+    public static unsafe bool InitSaltPersonal(
+        ref State state,
+        ReadOnlySpan<byte> key,
+        int outputLength,
+        ReadOnlySpan<byte> salt,
+        ReadOnlySpan<byte> personal)
+    {
+        if (key.Length > KeyBytesMax)
+            throw new ArgumentException("Key too large");
+
+        if (outputLength is < BytesMin or > BytesMax)
+            throw new ArgumentException("Output is invalid size");
+
+        fixed (crypto_generichash_blake2b_state* s = &state.Data)
+        fixed (byte* k = key)
+        fixed (byte* saltPtr = salt)
+        fixed (byte* p = personal)
+        {
+            var ret = crypto_generichash_blake2b_init_salt_personal(
+                s,
+                k, (nuint)key.Length,
+                (nuint)outputLength,
+                saltPtr,
+                p);
+
+            return ret == 0;
+        }
+    }
+
+    public static unsafe bool Update(ref State state, ReadOnlySpan<byte> input)
+    {
+        fixed (crypto_generichash_blake2b_state* s = &state.Data)
+        fixed (byte* i = input)
+        {
+            var ret = crypto_generichash_blake2b_update(s, i, (nuint)input.Length);
+            return ret == 0;
+        }
+    }
+
+    public static unsafe bool Final(ref State state, Span<byte> output)
+    {
+        if (output.Length is < BytesMin or > BytesMax)
+            throw new ArgumentException("Output is invalid size");
+
+        fixed (crypto_generichash_blake2b_state* s = &state.Data)
+        fixed (byte* o = output)
+        {
+            var ret = crypto_generichash_blake2b_final(s, o, (nuint)output.Length);
+            return ret == 0;
+        }
+    }
+
+    public struct State
+    {
+        public crypto_generichash_blake2b_state Data;
+    }
+}