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 *buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()]; crypto_generichash_blake2b_state *state_ = Align64(buffer); *state_ = state.blake2b; byte *temp = stackalloc byte[hash.Length]; int error = crypto_generichash_blake2b_final( state_, temp, (UIntPtr)hash.Length); Debug.Assert(error == 0); state.blake2b = *state_; fixed(byte * @out = hash) { return(CryptographicOperations.FixedTimeEquals(temp, @out, hash.Length)); } }
internal override void InitializeCore( out IncrementalHashState state) { int error = crypto_hash_sha512_init( out state.sha512); Debug.Assert(error == 0); }
internal 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); 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 InitializeCore( int hashSize, out IncrementalHashState state) { Debug.Assert(hashSize == crypto_hash_sha256_BYTES); int error = crypto_hash_sha256_init( out state.sha256); Debug.Assert(error == 0); }
internal override void UpdateCore( ref IncrementalHashState state, ReadOnlySpan <byte> data) { int error = crypto_hash_sha512_update( ref state.sha512, in data.GetPinnableReference(), (ulong)data.Length); Debug.Assert(error == 0); }
internal unsafe override void InitializeCore( out IncrementalHashState state) { fixed(crypto_hash_sha256_state *state_ = &state.sha256) { int error = crypto_hash_sha256_init( state_); Debug.Assert(error == 0); } }
internal override void FinalizeCore( ref IncrementalHashState state, Span <byte> hash) { Debug.Assert(hash.Length == crypto_hash_sha256_BYTES); int error = crypto_hash_sha256_final( ref state.sha256, ref hash.GetPinnableReference()); Debug.Assert(error == 0); }
internal unsafe override void UpdateCore( ref IncrementalHashState 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 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 void FinalizeCore( ref IncrementalHashState state, Span <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); temp.Slice(0, hash.Length).CopyTo(hash); }
internal unsafe override void FinalizeCore( ref IncrementalHashState state, Span <byte> hash) { Debug.Assert(hash.Length == crypto_hash_sha256_BYTES); fixed(crypto_hash_sha256_state *state_ = &state.sha256) fixed(byte * @out = hash) { int error = crypto_hash_sha256_final( state_, @out); Debug.Assert(error == 0); } }
internal unsafe override void InitializeCore( out IncrementalHashState state) { Debug.Assert(HashSize >= crypto_generichash_blake2b_BYTES_MIN); Debug.Assert(HashSize <= crypto_generichash_blake2b_BYTES_MAX); fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b) { int error = crypto_generichash_blake2b_init( state_, IntPtr.Zero, UIntPtr.Zero, (UIntPtr)HashSize); Debug.Assert(error == 0); } }
internal unsafe override void FinalizeCore( ref IncrementalHashState state, Span <byte> hash) { Debug.Assert(hash.Length >= crypto_generichash_blake2b_BYTES_MIN); Debug.Assert(hash.Length <= crypto_generichash_blake2b_BYTES_MAX); fixed(crypto_generichash_blake2b_state *state_ = &state.blake2b) fixed(byte * @out = hash) { int error = crypto_generichash_blake2b_final( state_, @out, (UIntPtr)hash.Length); Debug.Assert(error == 0); } }
internal unsafe override void InitializeCore( out IncrementalHashState state) { Debug.Assert(HashSize >= crypto_generichash_blake2b_BYTES_MIN); Debug.Assert(HashSize <= crypto_generichash_blake2b_BYTES_MAX); byte *buffer = stackalloc byte[63 + Unsafe.SizeOf <crypto_generichash_blake2b_state>()]; crypto_generichash_blake2b_state *state_ = Align64(buffer); int error = crypto_generichash_blake2b_init( state_, null, UIntPtr.Zero, (UIntPtr)HashSize); Debug.Assert(error == 0); state.blake2b = *state_; }
internal unsafe override void UpdateCore( ref IncrementalHashState 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 void FinalizeCore( ref IncrementalHashState state, Span <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) { Unsafe.CopyBlockUnaligned(@out, temp, (uint)hash.Length); } }
internal unsafe override bool FinalizeAndVerifyCore( ref IncrementalHashState state, ReadOnlySpan <byte> hash) { Debug.Assert(hash.Length == crypto_hash_sha256_BYTES); byte *temp = stackalloc byte[crypto_hash_sha256_BYTES]; fixed(crypto_hash_sha256_state *state_ = &state.sha256) { int error = crypto_hash_sha256_final( state_, temp); Debug.Assert(error == 0); } fixed(byte * @out = hash) { return(CryptographicOperations.FixedTimeEquals(temp, @out, hash.Length)); } }
internal unsafe override void FinalizeCore( ref IncrementalHashState state, Span <byte> hash) { Debug.Assert(hash.Length >= crypto_generichash_blake2b_BYTES_MIN); Debug.Assert(hash.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 = hash) { int error = crypto_generichash_blake2b_final( state_, @out, (UIntPtr)hash.Length); Debug.Assert(error == 0); } state.blake2b = *state_; }
internal abstract bool FinalizeAndVerifyCore( ref IncrementalHashState state, ReadOnlySpan <byte> hash);
internal abstract void FinalizeCore( ref IncrementalHashState state, Span <byte> hash);
internal abstract void InitializeCore( out IncrementalHashState state);
internal abstract void UpdateCore( ref IncrementalHashState state, ReadOnlySpan <byte> data);