👁 Image
SauceControl.Blake2Fast 2.0.0

These RFC 7693-compliant BLAKE2 implementations have been tuned for high speed and low memory usage. The .NET Core builds use the new x86 SIMD Intrinsics for even greater speed. Span{byte} is used throughout for lower memory overhead compared to byte[] based APIs.

On .NET Core 2.1+, Blake2Fast includes SSE4.1 SIMD-accelerated implementations of both BLAKE2b and BLAKE2s.

On .NET Core 3+, a faster AVX2 implementation of BLAKE2b is included in addition to the SSE4.1 implementation.

Usage

All-at-Once Hashing

The simplest and lightest-weight way to calculate a hash is the all-at-once ComputeHash method.

var hash = Blake2b.ComputeHash(data);

BLAKE2 supports variable digest lengths from 1 to 32 bytes for BLAKE2s or 1 to 64 bytes for BLAKE2b.

var hash = Blake2b.ComputeHash(42, data);

BLAKE2 also natively supports keyed hashing.

var hash = Blake2b.ComputeHash(key, data);

Incremental Hashing

BLAKE2 hashes can be incrementally updated if you do not have the data available all at once.

async Task<byte[]> ComputeHashAsync(Stream data)
{
 var hasher = Blake2b.CreateIncrementalHasher();
 var buffer = ArrayPool<byte>.Shared.Rent(4096);

 int bytesRead;
 while ((bytesRead = await data.ReadAsync(buffer, 0, buffer.Length)) > 0)
 hasher.Update(new Span<byte>(buffer, 0, bytesRead));

 ArrayPool<byte>.Shared.Return(buffer);
 return hasher.Finish();
}

Allocation-Free Hashing

The output hash digest can be written to an existing buffer to avoid allocating a new array each time.

Span<byte> buffer = stackalloc byte[Blake2b.DefaultDigestLength];
Blake2b.ComputeAndWriteHash(data, buffer);

This is especially useful when performing an iterative hash, as might be used in a key derivation function.

byte[] DeriveBytes(string password, ReadOnlySpan<byte> salt)
{
 // Create key from password, then hash the salt using the key
 var pwkey = Blake2b.ComputeHash(Encoding.UTF8.GetBytes(password));
 var hbuff = Blake2b.ComputeHash(pwkey, salt);

 // Hash the hash lots of times, re-using the same buffer
 for (int i = 0; i < 999_999; i++)
 Blake2b.ComputeAndWriteHash(pwkey, hbuff, hbuff);

 return hbuff;
}

System.Security.Cryptography Interop

For interoperating with code that uses System.Security.Cryptography primitives, Blake2Fast can create a HashAlgorithm wrapper. The wrapper inherits from HMAC in case keyed hashing is required.

HashAlgorithm is less efficient than the above methods, so use it only when necessary for compatibility.

byte[] WriteDataAndCalculateHash(byte[] data, string outFile)
{
 using (var hashAlg = Blake2b.CreateHashAlgorithm())
 using (var fileStream = new FileStream(outFile, FileMode.Create))
 using (var cryptoStream = new CryptoStream(fileStream, hashAlg, CryptoStreamMode.Write))
 {
 cryptoStream.Write(data, 0, data.Length);
 cryptoStream.FlushFinalBlock();
 return hashAlg.Hash;
 }
}