internal unsafe override void InitializeCore(
ReadOnlySpan <byte> key,
out IncrementalMacState state)
{
Debug.Assert(key.Length >= crypto_generichash_blake2b_KEYBYTES_MIN);
Debug.Assert(key.Length <= crypto_generichash_blake2b_KEYBYTES_MAX);
Debug.Assert(MacSize >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(MacSize <= crypto_generichash_blake2b_BYTES_MAX);
byte *buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()];
crypto_generichash_blake2b_state *state_ = Align64(buffer);
fixed(byte *k = key)
{
int error = crypto_generichash_blake2b_init(
state_,
k,
(UIntPtr)key.Length,
(UIntPtr)MacSize);
Debug.Assert(error == 0);
}
state.blake2b = *state_;
}
internal unsafe override bool FinalizeAndVerifyCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> mac)
{
Debug.Assert(mac.Length >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(mac.Length <= crypto_generichash_blake2b_BYTES_MAX);
byte *buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()];
crypto_generichash_blake2b_state *state_ = Align64(buffer);
*state_ = state.blake2b;
byte *temp = stackalloc byte[mac.Length];
int error = crypto_generichash_blake2b_final(
state_,
temp,
(UIntPtr)mac.Length);
Debug.Assert(error == 0);
fixed(byte * @out = mac)
{
return(CryptographicOperations.FixedTimeEquals(temp, @out, mac.Length));
}
}
internal override bool FinalizeAndVerifyCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> mac)
{
Debug.Assert(mac.Length >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(mac.Length <= crypto_generichash_blake2b_BYTES_MAX);
Span <byte> buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()];
ref crypto_generichash_blake2b_state state_ = ref AlignPinnedReference(ref buffer.GetPinnableReference());
internal override void UpdateCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> data)
{
int error = crypto_auth_hmacsha256_update(
ref state.hmacsha256,
in data.GetPinnableReference(),
(ulong)data.Length);
Debug.Assert(error == 0);
}
internal override void FinalizeCore(
ref IncrementalMacState state,
Span <byte> mac)
{
Debug.Assert(mac.Length == crypto_auth_hmacsha256_BYTES);
int error = crypto_auth_hmacsha256_final(
ref state.hmacsha256,
ref mac.GetPinnableReference());
Debug.Assert(error == 0);
}
internal override void InitializeCore(
ReadOnlySpan <byte> key,
out IncrementalMacState state)
{
Debug.Assert(key.Length == crypto_hash_sha256_BYTES);
int error = crypto_auth_hmacsha256_init(
out state.hmacsha256,
in key.GetPinnableReference(),
(UIntPtr)key.Length);
Debug.Assert(error == 0);
}
internal unsafe override void UpdateCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> data)
{
fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b)
fixed(byte * @in = data)
{
int error = crypto_generichash_blake2b_update(
state_,
@in,
(ulong)data.Length);
Debug.Assert(error == 0);
}
}
internal unsafe override void UpdateCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> data)
{
fixed(crypto_auth_hmacsha512_state *state_ = &state.hmacsha512)
fixed(byte * @in = data)
{
int error = crypto_auth_hmacsha512_update(
state_,
@in,
(ulong)data.Length);
Debug.Assert(error == 0);
}
}
internal override void FinalizeCore(
ref IncrementalMacState state,
Span <byte> mac)
{
Debug.Assert(mac.Length <= crypto_auth_hmacsha256_BYTES);
Span <byte> temp = stackalloc byte[crypto_auth_hmacsha256_BYTES];
int error = crypto_auth_hmacsha256_final(
ref state.hmacsha256,
ref temp.GetPinnableReference());
Debug.Assert(error == 0);
temp.Slice(0, mac.Length).CopyTo(mac);
}
internal unsafe override void InitializeCore(
SecureMemoryHandle keyHandle,
out IncrementalMacState state)
{
Debug.Assert(keyHandle.Size == crypto_hash_sha256_BYTES);
fixed(crypto_auth_hmacsha256_state *state_ = &state.hmacsha256)
{
int error = crypto_auth_hmacsha256_init(
state_,
keyHandle,
(UIntPtr)keyHandle.Size);
Debug.Assert(error == 0);
}
}
internal override bool FinalizeAndVerifyCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> mac)
{
Debug.Assert(mac.Length == crypto_auth_hmacsha256_BYTES);
Span <byte> temp = stackalloc byte[crypto_auth_hmacsha256_BYTES];
int error = crypto_auth_hmacsha256_final(
ref state.hmacsha256,
ref temp.GetPinnableReference());
Debug.Assert(error == 0);
return(CryptographicOperations.FixedTimeEquals(temp, mac));
}
internal unsafe override void InitializeCore(
ReadOnlySpan <byte> key,
out IncrementalMacState state)
{
Debug.Assert(key.Length == crypto_hash_sha256_BYTES);
fixed(crypto_auth_hmacsha256_state *state_ = &state.hmacsha256)
fixed(byte *k = key)
{
int error = crypto_auth_hmacsha256_init(
state_,
k,
(UIntPtr)key.Length);
Debug.Assert(error == 0);
}
}
internal unsafe override void FinalizeCore(
ref IncrementalMacState state,
Span <byte> mac)
{
Debug.Assert(mac.Length >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(mac.Length <= crypto_generichash_blake2b_BYTES_MAX);
fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b)
fixed(byte * @out = mac)
{
int error = crypto_generichash_blake2b_final(
state_,
@out,
(UIntPtr)mac.Length);
Debug.Assert(error == 0);
}
}
internal unsafe override void InitializeCore(
SecureMemoryHandle keyHandle,
out IncrementalMacState state)
{
Debug.Assert(keyHandle.Size >= crypto_generichash_blake2b_KEYBYTES_MIN);
Debug.Assert(keyHandle.Size <= crypto_generichash_blake2b_KEYBYTES_MAX);
Debug.Assert(MacSize >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(MacSize <= crypto_generichash_blake2b_BYTES_MAX);
fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b)
{
int error = crypto_generichash_blake2b_init(
state_,
keyHandle,
(UIntPtr)keyHandle.Size,
(UIntPtr)MacSize);
Debug.Assert(error == 0);
}
}
internal unsafe override void InitializeCore(
ReadOnlySpan <byte> key,
out IncrementalMacState state)
{
Debug.Assert(key.Length >= crypto_generichash_blake2b_KEYBYTES_MIN);
Debug.Assert(key.Length <= crypto_generichash_blake2b_KEYBYTES_MAX);
Debug.Assert(MacSize >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(MacSize <= crypto_generichash_blake2b_BYTES_MAX);
fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b)
fixed(byte *k = key)
{
int error = crypto_generichash_blake2b_init(
state_,
k,
(UIntPtr)key.Length,
(UIntPtr)MacSize);
Debug.Assert(error == 0);
}
}
internal unsafe override void UpdateCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> data)
{
byte *buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()];
crypto_generichash_blake2b_state *state_ = Align64(buffer);
*state_ = state.blake2b;
fixed(byte * @in = data)
{
int error = crypto_generichash_blake2b_update(
state_,
@in,
(ulong)data.Length);
Debug.Assert(error == 0);
}
state.blake2b = *state_;
}
internal unsafe override bool FinalizeAndVerifyCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> mac)
{
Debug.Assert(mac.Length <= crypto_auth_hmacsha256_BYTES);
byte *temp = stackalloc byte[crypto_auth_hmacsha256_BYTES];
fixed(crypto_auth_hmacsha256_state *state_ = &state.hmacsha256)
{
int error = crypto_auth_hmacsha256_final(
state_,
temp);
Debug.Assert(error == 0);
}
fixed(byte * @out = mac)
{
return(CryptographicOperations.FixedTimeEquals(temp, @out, mac.Length));
}
}
internal unsafe override void FinalizeCore(
ref IncrementalMacState state,
Span <byte> mac)
{
Debug.Assert(mac.Length <= crypto_auth_hmacsha256_BYTES);
byte *temp = stackalloc byte[crypto_auth_hmacsha256_BYTES];
fixed(crypto_auth_hmacsha256_state *state_ = &state.hmacsha256)
{
int error = crypto_auth_hmacsha256_final(
state_,
temp);
Debug.Assert(error == 0);
}
fixed(byte * @out = mac)
{
Unsafe.CopyBlockUnaligned(@out, temp, (uint)mac.Length);
}
}
internal unsafe override void FinalizeCore(
ref IncrementalMacState state,
Span <byte> mac)
{
Debug.Assert(mac.Length >= crypto_generichash_blake2b_BYTES_MIN);
Debug.Assert(mac.Length <= crypto_generichash_blake2b_BYTES_MAX);
byte *buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()];
crypto_generichash_blake2b_state *state_ = Align64(buffer);
*state_ = state.blake2b;
fixed(byte * @out = mac)
{
int error = crypto_generichash_blake2b_final(
state_,
@out,
(UIntPtr)mac.Length);
Debug.Assert(error == 0);
}
state.blake2b = *state_;
}
internal abstract void UpdateCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> data);
internal abstract void InitializeCore(
ReadOnlySpan <byte> key,
out IncrementalMacState state);
internal abstract void FinalizeCore(
ref IncrementalMacState state,
Span <byte> mac);
internal abstract bool FinalizeAndVerifyCore(
ref IncrementalMacState state,
ReadOnlySpan <byte> mac);
internal abstract void InitializeCore(
SecureMemoryHandle keyHandle,
out IncrementalMacState state);
