public async Task InitializeAsync(string passphrase, string salt)
{
await _serviceLock.WaitAsync().ConfigureAwait(false);
try
{
if (!Initialized)
{
_hashKey = await ArgonHash
.GetHashKeyAsync(passphrase, salt, Constants.EncryptionKeySize)
.ConfigureAwait(false);
await ChannelPool
.InitializeAsync()
.ConfigureAwait(false);
await AutoPublisher
.StartAsync(_hashKey)
.ConfigureAwait(false);
await FinishSettingUpConsumersAsync().ConfigureAwait(false);
Initialized = true;
}
}
finally
{ _serviceLock.Release(); }
}
public async Task ComcryptDecomcryptTest()
{
var message = new Message {
StringMessage = $"Sensitive ReceivedLetter 0", MessageId = 0
};
var data = JsonSerializer.SerializeToUtf8Bytes(message);
var hashKey = await ArgonHash
.GetHashKeyAsync(Passphrase, Salt, HouseofCat.Encryption.Constants.Aes256.KeySize)
.ConfigureAwait(false);
_output.WriteLine(Encoding.UTF8.GetString(hashKey));
_output.WriteLine($"HashKey: {Encoding.UTF8.GetString(hashKey)}");
// Comcrypt
var payload = await Gzip.CompressAsync(data);
var encryptedPayload = AesEncrypt.Aes256Encrypt(payload, hashKey);
// Decomcrypt
var decryptedData = AesEncrypt.Aes256Decrypt(encryptedPayload, hashKey);
Assert.NotNull(decryptedData);
var decompressed = await Gzip.DecompressAsync(decryptedData);
JsonSerializer.SerializeToUtf8Bytes(decompressed);
_output.WriteLine($"Data: {Encoding.UTF8.GetString(data)}");
_output.WriteLine($"Decrypted: {Encoding.UTF8.GetString(decryptedData)}");
Assert.Equal(data, decompressed);
}
public async Task ArgonHashTest()
{
var hashKey = await ArgonHash
.GetHashKeyAsync(Passphrase, Salt, 32)
.ConfigureAwait(false);
Assert.True(hashKey.Length == 32);
}
public ArgonAesEncryptionProvider(string passphrase, string salt, EncryptionMethod method, EncryptionOptions options = null)
{
Guard.AgainstNull(passphrase, nameof(passphrase));
Guard.AgainstNull(salt, nameof(salt));
_method = method;
_options = options;
_argonHashKey = ArgonHash.GetHashKeyAsync(passphrase, salt, Encryption.Constants.Aes256.KeySize, _options?.HashOptions).GetAwaiter().GetResult();
}
public async Task CheckFileHashAsyncTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
// Act
bool matches = await handler.CheckFileHashAsync(filename, fileHash);
// Assert
Assert.IsTrue(matches);
}
public async Task CheckHashFailTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
// Act
bool matches = await handler.CheckHashAsync(sample, failHash);
// Assert
Assert.IsFalse(matches);
}
public async Task GetHashAsyncTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
// Act
string hash = await handler.GetHashAsync(sample);
// Assert
Assert.IsTrue(hash.Length > 0);
}
public void Setup()
{
XorShift = new XorShift(true);
Payload1 = XorShift.GetRandomBytes(1024);
Payload2 = XorShift.GetRandomBytes(2048);
Payload3 = XorShift.GetRandomBytes(4096);
Payload4 = XorShift.GetRandomBytes(8192);
HashKey = ArgonHash
.GetHashKeyAsync(Passphrase, Salt, KeySize)
.GetAwaiter()
.GetResult();
}
public async Task CheckHashFailStreamTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(sample));
// Act
bool matches = await handler.CheckHashAsync(stream, failHash);
// Assert
Assert.IsFalse(matches);
}
public async Task GetHashAsyncStreamTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(sample));
// Act
string hash = await handler.GetHashAsync(stream);
// Assert
Assert.IsTrue(hash.Length > 0);
}
public async Task GetAndCheckHashTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
// Act
string hash = await handler.GetHashAsync(sample);
bool matches = await handler.CheckHashAsync(sample, hash);
// Assert
Assert.IsTrue(matches);
}
public async Task GetAndCheckHashStreamTest()
{
// Arrange
var handler = new ArgonHash(degrees, argonIterations, memorySpace, saltLength, hashLength);
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(sample));
// Act
string hash = await handler.GetHashAsync(stream);
stream.Position = 0;
bool matches = await handler.CheckHashAsync(stream, hash);
// Assert
Assert.IsTrue(matches);
}
/// <summary>
/// Builds out a RabbitService with instantiated dependencies based on config settings.
/// </summary>
/// <param name="config"></param>
/// <param name="passphrase"></param>
/// <param name="salt"></param>
/// <param name="loggerFactory"></param>
/// <param name="processReceiptAsync"></param>
public RabbitService(Config config, string passphrase, string salt, ILoggerFactory loggerFactory = null, Func <PublishReceipt, ValueTask> processReceiptAsync = null)
{
LogHelper.LoggerFactory = loggerFactory;
Config = config;
ChannelPool = new ChannelPool(Config);
if (!string.IsNullOrWhiteSpace(passphrase))
{
_hashKey = ArgonHash
.GetHashKeyAsync(passphrase, salt, Utils.Constants.EncryptionKeySize)
.GetAwaiter().GetResult();
}
Publisher = new Publisher(ChannelPool, _hashKey);
Topologer = new Topologer(ChannelPool);
BuildConsumers();
StartAsync(processReceiptAsync).GetAwaiter().GetResult();
}
public async Task EncryptDecryptTest()
{
var data = new byte[] { 0xFF, 0x00, 0xAA, 0xFF, 0x00, 0x00, 0xFF, 0xAA, 0x00, 0xFF, 0x00, 0xFF };
var hashKey = await ArgonHash
.GetHashKeyAsync(Passphrase, Salt, 32)
.ConfigureAwait(false);
_output.WriteLine(Encoding.UTF8.GetString(hashKey));
_output.WriteLine($"HashKey: {Encoding.UTF8.GetString(hashKey)}");
var encryptedData = AesEncrypt.Aes256Encrypt(data, hashKey);
_output.WriteLine($"Encrypted: {Encoding.UTF8.GetString(encryptedData)}");
var decryptedData = AesEncrypt.Aes256Decrypt(encryptedData, hashKey);
_output.WriteLine($"Data: {Encoding.UTF8.GetString(data)}");
_output.WriteLine($"Decrypted: {Encoding.UTF8.GetString(decryptedData)}");
Assert.Equal(data, decryptedData);
}
public async Task CreateArgonHashKeyAsync()
{
var hashKey = await ArgonHash
.GetHashKeyAsync(Passphrase, Salt, KeySize)
.ConfigureAwait(false);
}
