CryptoHives.Foundation.Threading 0.5.13-preview

🛡️ CryptoHives Open Source Initiative 🐝

An open, community-driven cryptography and performance library collection for the .NET ecosystem.

🏛️ CryptoHives .NET Foundation Libraries

The CryptoHives Open Source Initiative is a collection of modern, high-assurance libraries for .NET, developed and maintained by The Keepers of the CryptoHives. Each package is designed for security, interoperability, and clarity — making it easy to build secure systems for high performance transformation pipelines and for cryptography workloads without sacrificing developer experience.

📚 Documentation

• 📖 Full Documentation - Comprehensive guides, API reference, and examples
• 🚀 Getting Started Guide
• 📦 Package Documentation
• 📚 API Reference

🧬 Features and Design Principles

🧱 Orthogonal Design

• All development is done on free and open-source tools, e.g. .NET SDK, Visual Studio Community Edition, Visual Studio Code, GitHub, Azure DevOps, etc.
• Each package is designed to be orthogonal and composable with other CryptoHives packages to avoid deep cross dependencies
• Dependencies on other packages are kept to a minimum and shall only include widely adopted, well-maintained libraries, e.g. the Microsoft.Extensions
• OS and hardware dependencies are avoided wherever possible to ensure deterministic behavior across all platforms and runtimes, specifically for security implementations
• There is no intention to replace or shadow existing .NET class libraries; instead, CryptoHives packages are designed to complement and extend existing functionality

⚡ High-Performance Primitives

• All CryptoHives packages are designed for high performance and no operational allocations to optimize high performance transformation pipelines and cryptography workloads
• Algorithms may use managed SIMD intrinsics with scalar fallback.
• Package performance and memory usage are benchmarked against reference implementations

🔐 Secure Development Policy

• Standards-Based Cryptography – Implementations are written from official public specifications and standards (NIST, RFC, ISO)
• All algorithms are verified against official test vectors from specification documents
• Review process includes algorithm validation against reference implementations
• Threat-Modeled by Design – All public APIs and network interfaces assume hostile input
• Secure by Default & Validation – Minimal attack surface, explicit configuration, strict input checks, and resource bounds
• Dependency & Supply-Chain Safety – Minimal, vetted dependencies; reproducible signed (planned) releases.
• Automated Verification – Fuzzing (planned), static analysis, and safe error handling to prevent misuse and information leaks.
• Development may use AI-assisted tooling; no guarantee of clean-room provenance is claimed

🐝 Available CryptoHives

🛠️ Buffer Pools (Memory)

Pooled buffer management for transformation pipelines and high-frequency I/O:

• ArrayPoolMemoryStream — drop-in MemoryStream replacement backed by ArrayPool<byte> with ReadOnlySequence handoff support
• ReadOnlySequenceMemoryStream — read from ReadOnlySequence<byte> as MemoryStream without copying
• ArrayPoolBufferWriter<T> — IBufferWriter<T> over pooled arrays for e.g. Utf8JsonWriter
• Ownership primitives for zero-copy handoff of pooled buffers

🚀 Concurrency Tools (Threading)

Async-compatible synchronization primitives built on ObjectPool and ValueTask<T>. Designed to eliminate Task / TaskCompletionSource<T> allocations on the hot path.

• AsyncLock — mutual exclusion
• AsyncSemaphore — counting semaphore
• AsyncAutoResetEvent / AsyncManualResetEvent
• AsyncReaderWriterLock
• AsyncBarrier / AsyncCountdownEvent

All primitives support CancellationToken and ConfigureAwait(false) without the need for extra allocations. Nuget package contains a C# analyzer to avoid common ValueTask usage mistakes. (Also available as standalone package)

⏱️ Async primitive benchmarks — contested and uncontested scenarios, comparing pooled ValueTask vs. existing Task-based alternatives.

🔐 Managed Code Cryptography (Security.Cryptography)

Fully managed implementations of cryptographic hash algorithms, MACs, and cipher algorithms, written from NIST/RFC/ISO specifications and verified against official test vectors. No OS crypto dependency — deterministic results on every platform. Hardware acceleration via AES-NI, PCLMULQDQ, VPCLMULQDQ, SSE2, SSSE3, and AVX2 intrinsics is automatically enabled on supported hardware, in some cases even outperforming OS implementations.

Algorithms:

All XOF algorithms implement IExtendableOutput for streaming variable-length output via Absorb / Squeeze / Reset.

⏱️ Cryptography Benchmarks

Measured with BenchmarkDotNet across various payloads, comparing managed vs. reference vs. OS implementations.

• Hash algorithms
• Cipher algorithms

📦 Nuget Packages

Package	Description	NuGet	Documentation
Memory	Pooled buffers and streams		Docs
Threading	Pooled async synchronization		Docs
Security.Cryptography	Hash, MAC & cipher algorithms		Docs

All packages are published under the CryptoHives.Foundation prefix and namespace — see the Nuget CryptoHives for details.

🩺 CryptoHives Health

🧩 Installation

Install via NuGet CLI:

dotnet add package CryptoHives.Foundation.Threading

Or using the Visual Studio Package Manager:

Install-Package CryptoHives.Foundation.Threading

🧠 Usage Examples

using CryptoHives.Foundation.Security.Cryptography.Hash;

// Allocation-free hash
using var blake3 = Blake3.Create();
Span<byte> hash = stackalloc byte[32];
blake3.TryComputeHash(data, hash, out _);

// XOF streaming (variable-length output)
using var shake = Shake256.Create(64);
shake.Absorb(data1);
shake.Absorb(data2);
Span<byte> output = stackalloc byte[128];
shake.Squeeze(output);

using CryptoHives.Foundation.Threading.Async.Pooled;

// Allocation-free async lock, even with cancellation token
private readonly AsyncLock _lock = new();

public async Task DoWorkAsync(CancellationToken ct)
{
    using await _lock.LockAsync(ct).ConfigureAwait(false);
    // critical section
}

🔐 Security Policy

Security is our top priority.

If you discover a vulnerability, please do not open a public issue.
Instead, please follow the guidelines on the CryptoHives Open Source Initiative Security Page.

🔏 Nuget Package Assembly Code Signing

Assemblies in our Nuget packages are currently not code signed. Once there is sufficient demand and funding available, the Keepers plan to implement code signing for all released packages.

📝 No-Nonsense Matters

This project is released under the MIT License because open collaboration matters.
However, the Keepers are well aware that MIT-licensed code often gets copied, repackaged, or commercialized without giving credit.

If you use this code, please do so responsibly:

• Give visible credit to the CryptoHives Open Source Initiative or The Keepers of the CryptoHives and refer to the original source.
• Contribute improvements back and report issues.

Open source thrives on respect, not just permissive licenses.

⚖️ License

Each component of the CryptoHives Open Source Initiative is licensed under a SPDX-compatible MIT license.
By default, packages use the following license tags:

// SPDX-FileCopyrightText: <year> The Keepers of the CryptoHives
// SPDX-License-Identifier: MIT

Some inherited components may use alternative MIT license headers, according to their origin and specific requirements those headers are retained.

🐝 About The Keepers of the CryptoHives

The CryptoHives Open Source Initiative project is maintained by The Keepers of the CryptoHives —
a collective of developers dedicated to advancing open, verifiable, and high-performance cryptography in .NET.

🧩 Contributing

Contributions, issue reports, and pull requests are welcome!

Please see the Contributing Guide before submitting code.

© 2026 The Keepers of the CryptoHives