ktsu Common Providers

A comprehensive collection of provider implementations for the ktsu ecosystem. This library provides standardized implementations of interfaces defined in ktsu.Abstractions, enabling consistent patterns across serialization, hashing, compression, encryption, file system access, and obfuscation.

Available Providers

Serialization Providers

Implementations of ISerializationProvider for popular JSON libraries:

Hash Providers

Implementations of IHashProvider for cryptographic and non-cryptographic hash algorithms:

Compression Providers

Implementations of ICompressionProvider:

Encryption Providers

Implementations of IEncryptionProvider:

File System Providers

Implementations of IFileSystemProvider:

Obfuscation Providers

Implementations of IObfuscationProvider:

Installation

Install the specific provider packages you need:

# Serialization
dotnet add package ktsu.SerializationProviders.NewtonsoftJson
dotnet add package ktsu.SerializationProviders.SystemTextJson

# Hashing
dotnet add package ktsu.HashProviders.SHA256
dotnet add package ktsu.HashProviders.MD5
# ... other hash providers

# Compression
dotnet add package ktsu.CompressionProviders.Gzip

# Encryption
dotnet add package ktsu.EncryptionProviders.Aes

# File System
dotnet add package ktsu.FileSystemProviders.Native

# Obfuscation
dotnet add package ktsu.ObfuscationProviders.Base64

Usage

Serialization

using ktsu.Abstractions;
using ktsu.SerializationProviders.SystemTextJson;

ISerializationProvider serializer = new SystemTextJson();

// Serialize
using var writer = new StringWriter();
if (serializer.TrySerialize(myObject, writer))
{
    string json = writer.ToString();
}

// Deserialize
byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonString);
var result = serializer.Deserialize<MyClass>(jsonBytes.AsSpan());

Hashing

using ktsu.Abstractions;
using ktsu.HashProviders.SHA256;

using IHashProvider hasher = new SHA256();

byte[] data = Encoding.UTF8.GetBytes("Hello, World!");
Span<byte> hash = stackalloc byte[hasher.HashLengthBytes];

if (hasher.TryHash(data, hash))
{
    string hashHex = Convert.ToHexString(hash);
}

// Hash from stream
using var stream = File.OpenRead("file.txt");
if (hasher.TryHash(stream, hash))
{
    // hash contains the file hash
}

Compression

using ktsu.Abstractions;
using ktsu.CompressionProviders.Gzip;

ICompressionProvider compressor = new Gzip();

byte[] original = Encoding.UTF8.GetBytes("Data to compress");

// Compress
if (compressor.TryCompress(original, out byte[] compressed))
{
    // Use compressed data
}

// Decompress
if (compressor.TryDecompress(compressed, out byte[] decompressed))
{
    string text = Encoding.UTF8.GetString(decompressed);
}

Encryption

using ktsu.Abstractions;
using ktsu.EncryptionProviders.Aes;

using IEncryptionProvider encryptor = new Aes();

byte[] key = new byte[32]; // 256-bit key
byte[] iv = new byte[16];  // 128-bit IV
RandomNumberGenerator.Fill(key);
RandomNumberGenerator.Fill(iv);

byte[] plaintext = Encoding.UTF8.GetBytes("Secret message");

// Encrypt
if (encryptor.TryEncrypt(plaintext, key, iv, out byte[] ciphertext))
{
    // Store or transmit ciphertext
}

// Decrypt
if (encryptor.TryDecrypt(ciphertext, key, iv, out byte[] decrypted))
{
    string message = Encoding.UTF8.GetString(decrypted);
}

Dependency Injection

All providers integrate seamlessly with Microsoft.Extensions.DependencyInjection:

using Microsoft.Extensions.DependencyInjection;
using ktsu.Abstractions;

var services = new ServiceCollection();

// Register specific providers
services.AddSingleton<ISerializationProvider, SystemTextJson>();
services.AddSingleton<IHashProvider, SHA256>();
services.AddSingleton<ICompressionProvider, Gzip>();
services.AddSingleton<IEncryptionProvider, Aes>();
services.AddSingleton<IFileSystemProvider, Native>();
services.AddSingleton<IObfuscationProvider, Base64>();

var provider = services.BuildServiceProvider();

// Resolve and use
var serializer = provider.GetRequiredService<ISerializationProvider>();
var hasher = provider.GetRequiredService<IHashProvider>();

Features

• Consistent APIs - All providers implement standardized interfaces from ktsu.Abstractions
• Graceful Error Handling - Methods return success/failure indicators rather than throwing exceptions
• Multi-Target Support - .NET 9.0, 8.0, 7.0, 6.0, and .NET Standard 2.1
• Dependency Injection Ready - Easy integration with DI containers
• Provider Pattern - Swap implementations without changing consumer code
• Disposable Resources - Providers that hold resources implement IDisposable

Error Handling

All providers follow consistent error handling patterns:

// Hash providers return false on failure
if (!hasher.TryHash(data, destination))
{
    // Handle failure (buffer too small, disposed, etc.)
}

// Serialization returns false/default on failure
if (!serializer.TrySerialize(obj, writer))
{
    // Handle serialization failure
}

var result = serializer.Deserialize<MyClass>(invalidData);
if (result == null)
{
    // Handle deserialization failure
}

// Compression/Encryption use out parameters
if (!compressor.TryCompress(data, out byte[] compressed))
{
    // Handle compression failure
}

Requirements

• .NET 9.0, 8.0, 7.0, 6.0, or .NET Standard 2.1
• ktsu.Abstractions package

License

Licensed under the MIT License. See LICENSE.md for details.

Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.