internal override string TransformResult(RedisValue value)
{
string encoded = (string)value;
byte[] decoded = Convert.FromBase64String(encoded);
byte[] decrypted = EncryptionHelpers.DecryptDataAsync(decoded, _encryptionKey).ConfigureAwait(false).GetAwaiter().GetResult();
return(Encoding.UTF8.GetString(decrypted));
}
public async Task DecryptDataAsync_WithValidData_ReturnsEncryptedArray()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
byte[] data = new byte[128];
byte[] encrypted = await EncryptionHelpers.EncryptDataAsync(data, key);
byte[] result = await EncryptionHelpers.DecryptDataAsync(encrypted, key);
Assert.Equal(data, result);
}
internal override void ReceiveHandler(RedisChannel channel, RedisValue value)
{
try
{
string encoded = (string)value;
byte[] decoded = Convert.FromBase64String(encoded);
byte[] decrypted = EncryptionHelpers.DecryptDataAsync(decoded, _encryptionKey).ConfigureAwait(false).GetAwaiter().GetResult();
string data = Encoding.UTF8.GetString(decrypted);
base.ReceiveHandler(channel, data);
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Failed decrypting on Channel {Channel}: {Value}", _channel, value);
}
}
internal override async Task <EventMessage> GetEventMessageAsync(EventData eventData)
{
EventMessage decrypted;
byte[] decryptedData = await EncryptionHelpers.DecryptDataAsync(eventData.Body.Array, _encryptionKey).ConfigureAwait(false);
using (EventData data = new EventData(decryptedData))
{
data.SystemProperties = eventData.SystemProperties;
foreach (KeyValuePair <string, object> kv in eventData.Properties)
{
data.Properties.Add(kv);
}
decrypted = new EventMessage(data);
}
return(decrypted);
}
public async Task EncryptingAndDecrypting_WithReadOnlyMemory_Works()
{
byte[] randBytes = new byte[512];
Random rnd = new Random();
rnd.NextBytes(randBytes);
ReadOnlyMemory <byte> data = new ReadOnlyMemory <byte>(randBytes);
byte[] key = EncryptionHelpers.CreateEncryptionKey();
byte[] encrypted = await EncryptionHelpers.EncryptDataAsync(data, key);
ReadOnlyMemory <byte> encryptedData = new ReadOnlyMemory <byte>(encrypted);
byte[] decrypted = await EncryptionHelpers.DecryptDataAsync(encrypted, key);
Assert.Equal(randBytes, decrypted);
}
protected override T DeserializeObject <T>(string value)
{
try
{
byte[] encrypted = Convert.FromBase64String(value);
byte[] decrypted = EncryptionHelpers.DecryptDataAsync(encrypted, _encryptionKey).ConfigureAwait(false).GetAwaiter().GetResult();
string strdata = Encoding.UTF8.GetString(decrypted);
return(base.DeserializeObject <T>(strdata));
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Failed decrypting {Value}", value);
#nullable disable // Nullable doesn't work with generics and default
return(default(T));
#nullable enable
}
protected override async Task OnMessageReceivedAsync(RedisValue message)
{
try
{
// Decrypt the message then push to the base function for processing
string decryptedMsg;
QueueMessage msg = base.DeserializeObject <QueueMessage>(message);
byte[] encryptedBytes = Convert.FromBase64String(msg.Content);
byte[] decryptedBytes = await EncryptionHelpers.DecryptDataAsync(encryptedBytes, _encryptionKey).ConfigureAwait(false);
string decrypted = Encoding.UTF8.GetString(decryptedBytes);
msg.Content = decrypted;
decryptedMsg = base.SerializeObject(msg);
await base.OnMessageReceivedAsync(decryptedMsg);
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Failed decrypting on Queue {Name}: {Value}", _queueName, message);
}
}
/// <inheritdoc />
internal override async Task <List <EventMessage> > ProcessMessagesAsync(StreamEntry[] entries)
{
List <EventMessage> messages = await base.ProcessMessagesAsync(entries);
foreach (EventMessage msg in messages)
{
try
{
string?content = msg.Content as string;
if (content != null)
{
byte[] encrypted = Convert.FromBase64String(content);
byte[] plaintextBytes = await EncryptionHelpers.DecryptDataAsync(encrypted, _encryptionKey).ConfigureAwait(false);
string plaintext = Encoding.UTF8.GetString(plaintextBytes);
msg.Content = plaintext;
}
else
{
msg.Content = string.Empty;
}
}
catch (Exception ex)
{
Log.Logger.Error(
ex,
"Failed decrypting on Stream {Name} Consumer Group {Group} Consumer {Consumer} at {Offset}-{Sequence}: {Value}",
_streamName,
_consumerGroup,
_consumerName,
msg.Offset,
msg.SequenceNumber,
msg.Content?.ToString() ?? string.Empty);
}
}
return(messages);
}
/// <inheritdoc />
protected override async Task <QueueMessage> GetQueueMessageAsync(ReadOnlyMemory <byte> body, IBasicProperties properties, bool redelivered, ulong messageId)
{
byte[] decrypted = await EncryptionHelpers.DecryptDataAsync(body, _encryptionKey);
return(new QueueMessage(properties, decrypted, redelivered, messageId));
}
public async Task DecryptDataAsync_WithEmptyEncryptionKey_Throws()
{
byte[] data = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await EncryptionHelpers.DecryptDataAsync(data, Array.Empty <byte>()));
}
public async Task DecryptDataAsync_WithNullEncryptionKey_Throws()
{
byte[] data = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentNullException>(async() => await EncryptionHelpers.DecryptDataAsync(data, null));
}