internal override bool FinalizeAndVerifyCore( ref IncrementalHashState state, ReadOnlySpan <byte> hash) { Debug.Assert(hash.Length <= crypto_hash_sha512_BYTES); Span <byte> temp = stackalloc byte[crypto_hash_sha512_BYTES]; int error = crypto_hash_sha512_final( ref state.sha512, ref temp.GetPinnableReference()); Debug.Assert(error == 0); return(CryptographicOperations.FixedTimeEquals(temp.Slice(0, hash.Length), hash)); }
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)); }
private protected override bool VerifyCore( ReadOnlySpan <byte> key, ReadOnlySpan <byte> data, ReadOnlySpan <byte> mac) { Debug.Assert(key.Length == crypto_hash_sha256_BYTES); Debug.Assert(mac.Length == crypto_auth_hmacsha256_BYTES); Span <byte> temp = stackalloc byte[crypto_auth_hmacsha256_BYTES]; crypto_auth_hmacsha256_init(out crypto_auth_hmacsha256_state state, in key.GetPinnableReference(), (UIntPtr)key.Length); crypto_auth_hmacsha256_update(ref state, in data.GetPinnableReference(), (ulong)data.Length); crypto_auth_hmacsha256_final(ref state, ref temp.GetPinnableReference()); return(CryptographicOperations.FixedTimeEquals(temp, mac)); }
private protected override bool VerifyCore( ReadOnlySpan <byte> data, ReadOnlySpan <byte> hash) { Debug.Assert(hash.Length <= crypto_hash_sha512_BYTES); Span <byte> temp = stackalloc byte[crypto_hash_sha512_BYTES]; int error = crypto_hash_sha512( ref temp.GetPinnableReference(), in data.GetPinnableReference(), (ulong)data.Length); Debug.Assert(error == 0); return(CryptographicOperations.FixedTimeEquals(temp.Slice(0, hash.Length), hash)); }
private static void ExpandCore( ReadOnlySpan <byte> pseudorandomKey, ReadOnlySpan <byte> info, Span <byte> bytes) { Debug.Assert(pseudorandomKey.Length >= crypto_auth_hmacsha512_BYTES); Debug.Assert(bytes.Length <= byte.MaxValue * crypto_auth_hmacsha512_BYTES); Span <byte> temp = stackalloc byte[crypto_auth_hmacsha512_BYTES]; try { int tempLength = 0; int offset = 0; byte counter = 0; int chunkSize; while ((chunkSize = bytes.Length - offset) > 0) { counter++; crypto_auth_hmacsha512_init(out crypto_auth_hmacsha512_state state, in pseudorandomKey.GetPinnableReference(), (UIntPtr)pseudorandomKey.Length); crypto_auth_hmacsha512_update(ref state, in temp.GetPinnableReference(), (ulong)tempLength); crypto_auth_hmacsha512_update(ref state, in info.GetPinnableReference(), (ulong)info.Length); crypto_auth_hmacsha512_update(ref state, in counter, sizeof(byte)); crypto_auth_hmacsha512_final(ref state, ref temp.GetPinnableReference()); tempLength = crypto_auth_hmacsha512_BYTES; if (chunkSize > crypto_auth_hmacsha512_BYTES) { chunkSize = crypto_auth_hmacsha512_BYTES; } temp.Slice(0, chunkSize).CopyTo(bytes.Slice(offset)); offset += chunkSize; } } finally { CryptographicOperations.ZeroMemory(temp); } }
private protected override void DeriveBytesCore( ReadOnlySpan <byte> inputKeyingMaterial, ReadOnlySpan <byte> salt, ReadOnlySpan <byte> info, Span <byte> bytes) { Debug.Assert(bytes.Length <= byte.MaxValue * crypto_auth_hmacsha512_BYTES); Span <byte> pseudorandomKey = stackalloc byte[crypto_auth_hmacsha512_BYTES]; try { ExtractCore(inputKeyingMaterial, salt, pseudorandomKey); ExpandCore(pseudorandomKey, info, bytes); } finally { CryptographicOperations.ZeroMemory(pseudorandomKey); } }
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 bool FinalizeAndVerifyCore( ref IncrementalHashState state, ReadOnlySpan <byte> hash) { Debug.Assert(hash.Length <= crypto_hash_sha512_BYTES); byte *temp = stackalloc byte[crypto_hash_sha512_BYTES]; fixed(crypto_hash_sha512_state *state_ = &state.sha512) { int error = crypto_hash_sha512_final( state_, temp); Debug.Assert(error == 0); } fixed(byte * @out = hash) { return(CryptographicOperations.FixedTimeEquals(temp, @out, hash.Length)); } }
private protected unsafe override bool VerifyCore( ReadOnlySpan <byte> data, ReadOnlySpan <byte> hash) { Debug.Assert(hash.Length == crypto_hash_sha256_BYTES); byte *temp = stackalloc byte[crypto_hash_sha256_BYTES]; fixed(byte * @in = data) { int error = crypto_hash_sha256( temp, @in, (ulong)data.Length); Debug.Assert(error == 0); } fixed(byte * @out = hash) { return(CryptographicOperations.FixedTimeEquals(temp, @out, hash.Length)); } }
internal unsafe override bool FinalizeAndVerifyCore( ref IncrementalHashState state, ReadOnlySpan <byte> hash) { Debug.Assert(hash.Length >= crypto_generichash_blake2b_BYTES_MIN); Debug.Assert(hash.Length <= crypto_generichash_blake2b_BYTES_MAX); byte *temp = stackalloc byte[hash.Length]; fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b) { int error = crypto_generichash_blake2b_final( state_, temp, (UIntPtr)hash.Length); Debug.Assert(error == 0); } fixed(byte * @out = hash) { return(CryptographicOperations.FixedTimeEquals(temp, @out, hash.Length)); } }