StreamHash 1.11.2

StreamHash

StreamHash is a high-performance, memory-efficient streaming hash library for .NET 10+. All 70 hash algorithms are implemented natively in pure C# with zero heavy dependencies — just one lightweight package (System.IO.Hashing) for CRC/xxHash acceleration.

🎯 Why StreamHash?

• Single package, all algorithms: One NuGet install gives you 70 hash algorithms — no BouncyCastle, no native binaries, no transitive dependency hell
• Streaming everything: Many popular algorithms (MurmurHash, CityHash, SpookyHash, etc.) lack streaming APIs. Hashing a 10GB file normally requires 10GB of RAM! StreamHash processes data in chunks using ~16MB regardless of file size
• Competitive performance: Native C# implementations match or beat external libraries for most algorithms — see benchmarks

✨ Features

• 🚀 Memory Efficient: Hash multi-gigabyte files with minimal memory footprint
• ⚡ High Performance: Optimized implementations with SIMD where available (Grøstl AES-NI, JH SSSE3, HighwayHash AVX2, BLAKE2b AVX2, CRC-32C SSE4.2)
• 🔄 Streaming API: Process data incrementally with Update() and Finalize()
• 📦 Zero Allocations: Hot paths are allocation-free using Span<T>
• 🎯 Unified API: HashFacade provides access to all 70 algorithms through a single interface
• 🔐 All-Native Crypto: Every cryptographic algorithm implemented in pure C# — no BouncyCastle dependency
• ⚡ Batch Streaming: Process 70 algorithms in parallel with CreateAllStreaming()
• 🧪 Thoroughly Tested: 1853+ tests validating against official test vectors
• 📦 Minimal Dependencies: Only System.IO.Hashing — no large transitive dependency chains

🚀 Quick Start

Installation

dotnet add package StreamHash --version 1.11.2

One-Shot Hashing (Simplest)

using StreamHash.Core;

byte[] data = File.ReadAllBytes("file.bin");

// Compute a single hash
string hex = HashFacade.ComputeHashHex(HashAlgorithm.Sha256, data);
byte[] hash = HashFacade.ComputeHash(HashAlgorithm.XxHash64, data);

// Get algorithm info
var info = HashFacade.GetInfo(HashAlgorithm.Sha256);
Console.WriteLine($"{info.DisplayName}: {info.DigestSize} bytes, Crypto: {info.IsCryptographic}");

Streaming a Single Algorithm

For large files that don't fit in memory:

using StreamHash.Core;

using var hasher = HashFacade.CreateStreaming(HashAlgorithm.MurmurHash3_128);
using var stream = File.OpenRead("large-file.bin");

byte[] buffer = new byte[1024 * 1024]; // 1MB buffer
int bytesRead;
while ((bytesRead = stream.Read(buffer)) > 0) {
	hasher.Update(buffer.AsSpan(0, bytesRead));
}

byte[] result = hasher.FinalizeBytes();
string hex = hasher.FinalizeHex();

Batch Streaming — All 70 Algorithms at Once

Hash a file with all 70 algorithms in parallel, in a single pass:

using StreamHash.Core;

using var multi = HashFacade.CreateAllStreaming();
using var stream = File.OpenRead("large-file.bin");

byte[] buffer = new byte[16 * 1024 * 1024]; // 16MB buffer recommended
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0) {
	multi.Update(buffer.AsSpan(0, read));
}

Dictionary<string, string> results = multi.FinalizeAll();
// results["SHA256"] = "abc123..."
// results["MD5"] = "def456..."
// ... all 70 algorithms

Basic Hashes — The 4 Most Common

For the common case of verifying files with CRC32, MD5, SHA-1, and SHA-256:

using StreamHash.Core;

using var basicHasher = HashFacade.CreateBasicHashesStreaming();
using var stream = File.OpenRead("download.zip");

var buffer = new byte[16 * 1024 * 1024];
int bytesRead;
while ((bytesRead = stream.Read(buffer)) > 0) {
	basicHasher.Update(buffer.AsSpan(0, bytesRead));
}

var results = basicHasher.FinalizeAll();
Console.WriteLine($"CRC32:   {results[HashAlgorithmNames.Crc32]}");
Console.WriteLine($"MD5:     {results[HashAlgorithmNames.Md5]}");
Console.WriteLine($"SHA-1:   {results[HashAlgorithmNames.Sha1]}");
Console.WriteLine($"SHA-256: {results[HashAlgorithmNames.Sha256]}");

Tip: Use HashAlgorithmNames constants instead of string literals to avoid typos!

Direct Type API

You can also instantiate algorithm types directly:

using StreamHash.Core;

using var hasher = new MurmurHash3_128();
hasher.Update(chunk1);
hasher.Update(chunk2);
UInt128 hash = hasher.Finalize();

📊 Algorithm Support (70 Algorithms)

All algorithms are implemented in pure native C# with zero true unsafe code.

⚡ Performance Highlights

StreamHash's native C# matches or beats external libraries for most algorithms:

• 4.9x faster: Whirlpool vs BouncyCastle
• 2.5x faster: SHA-1 (.NET hardware acceleration)
• 1.8x faster: RIPEMD-128, Streebog-256
• At parity: BLAKE3 (matches Rust native!), SHA3 family, CRC, xxHash
• 20 algorithms faster than BouncyCastle, only 2 meaningfully slower (BLAKE2b/2s with AVX2 SIMD)

Full benchmark data with detailed comparisons at all data sizes: Performance Benchmarks

📖 Documentation

• 📚 Algorithm Reference — all 70 algorithms documented
• 📈 Performance Benchmarks — detailed comparisons vs BouncyCastle, System.IO.Hashing, Blake2Fast
• 📋 Reference Hash Values — test vectors and expected outputs
• 📦 NuGet Publishing — package build and release process
• 📝 Changelog — version history and release notes

Algorithm Documentation

🏗️ Building

git clone https://github.com/TheAnsarya/StreamHash.git
cd StreamHash
dotnet build StreamHash.slnx
dotnet test    # 1853+ tests

📄 License

This project is released into the public domain under The Unlicense. Do whatever you want with it.

🙏 Acknowledgments & References

As of v1.11.0, all 70 algorithms are implemented natively in StreamHash with no external hash library dependencies. The following projects were invaluable as reference implementations and inspiration:

Reference Implementations

• BouncyCastle.Cryptography — Reference for MD2, MD4, SHA-224, SHA-512/224, SHA-512/256, RIPEMD-256/320, GOST-94, Streebog-256/512, Skein-256/512/1024, SM3, BLAKE2b/2s. MIT License.
• acryptohashnet — Reference for Keccak-256/512, RIPEMD-128/160, Tiger-192, SHA-0. MIT License.
• SauceControl.Blake2Fast — BLAKE2 SIMD reference with SSE2-AVX512. MIT License.
• Blake3.NET — BLAKE3 reference (Rust SIMD). Apache 2.0/MIT License.
• nebulae.dotSHA3 — SHA-3 XKCP reference with AVX2/NEON. MIT License.

Algorithm References

• SMHasher — MurmurHash reference implementation
• CityHash — Google's CityHash
• SpookyHash — Bob Jenkins' SpookyHash
• SipHash — Reference SipHash implementation
• XKCP — Keccak/SHA-3 reference implementations
• RFC 7693 — BLAKE2 specification