public void CreateEncryptionKey_WithValidSpecifiedKeySize_DoesNotCreateNullKey(int keySize)
{
byte[] key = EncryptionHelpers.CreateEncryptionKey(keySize);
Assert.NotNull(key);
Assert.NotEmpty(key);
Assert.False(Array.TrueForAll(key, k => k == 0));
}
public void CreateEncryptionKey_CreatesNonNullKey()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
Assert.NotNull(key);
Assert.NotEmpty(key);
Assert.False(Array.TrueForAll(key, k => k == 0));
}
public async Task GetEncryptionStreamAsync_WithValidData_WritesEncryptedData()
{
byte[] original = new byte[128];
byte[] result;
byte[] key = EncryptionHelpers.CreateEncryptionKey();
new Random().NextBytes(original);
using (MemoryStream ms = new MemoryStream())
{
using (Stream stream = await EncryptionHelpers.GetEncryptionStreamAsync(key, ms))
{
await stream.WriteAsync(original, 0, original.Length);
}
result = ms.ToArray();
}
Assert.NotNull(result);
Assert.NotEmpty(result);
Assert.NotEqual(original, result);
byte[] iv = new byte[16];
Array.Copy(result, iv, 16);
byte[] encrypted = new byte[result.Length - iv.Length];
Array.Copy(result, encrypted, encrypted.Length);
Assert.NotEqual(original, encrypted);
Assert.Equal(result.Length, iv.Length + encrypted.Length);
}
public void CreateEncryptionKey_CreatesDifferentKeysWithMultipleCalls()
{
byte[] key1 = EncryptionHelpers.CreateEncryptionKey();
byte[] key2 = EncryptionHelpers.CreateEncryptionKey();
Assert.NotNull(key1);
Assert.NotEmpty(key1);
Assert.NotEqual(key1, key2);
}
public async Task EncryptDataAsync_WithValidData_ReturnsEncryptedArray()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
byte[] data = new byte[128];
new Random().NextBytes(data);
byte[] result = await EncryptionHelpers.EncryptDataAsync(data, key);
Assert.NotEqual(data, result);
}
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);
}
public async Task EnsureDisposeWorks()
{
FieldInfo f;
byte[] key = EncryptionHelpers.CreateEncryptionKey();
using (MemoryStream ms = new MemoryStream())
{
CryptographicStream s = await EncryptionHelpers.GetEncryptionStreamAsync(key, ms);
f = s.GetType().GetField("_underlyingStream", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(f.GetValue(s));
s.Dispose();
Assert.Null(f.GetValue(s));
}
}
public void EncryptDecrypt_NonAllocating_Works()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey(128);
string data = "Hello, Encryption World!";
byte[] plaintext = System.Text.Encoding.UTF8.GetBytes(data);
using (IMemoryOwner <byte> encrypted = MemoryPool <byte> .Shared.Rent(128))
using (IMemoryOwner <byte> decrypted = MemoryPool <byte> .Shared.Rent(128))
{
int encryptedCount = EncryptionHelpers.EncryptData(plaintext.AsMemory(), encrypted.Memory, key);
int decryptedCount = EncryptionHelpers.DecryptData(encrypted.Memory.Slice(0, encryptedCount), decrypted.Memory, key);
Assert.Equal(plaintext.Length, decryptedCount);
string final = System.Text.Encoding.UTF8.GetString(decrypted.Memory.Span.Slice(0, decryptedCount));
Assert.Equal(data, final);
}
}
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);
}
public async Task GetDecryptionStreamAsync_WithValidData_WritesDecryptedData()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
byte[] original = new byte[128];
new Random().NextBytes(original);
byte[] encrypted = await EncryptionHelpers.EncryptDataAsync(original, key);
byte[] result;
using (MemoryStream ms = new MemoryStream(encrypted))
using (MemoryStream output = new MemoryStream())
{
using (Stream stream = await EncryptionHelpers.GetDecryptionStreamAsync(key, ms))
{
await stream.CopyToAsync(output);
}
result = output.ToArray();
}
Assert.NotNull(result);
Assert.NotEmpty(result);
Assert.Equal(original, result);
}
public async Task EncryptDataAsync_WithEmptyEncryptionKey_Throws()
{
byte[] data = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await EncryptionHelpers.EncryptDataAsync(data, Array.Empty <byte>()));
}
public async Task EncryptDataAsync_WithNullEncryptionKey_Throws()
{
byte[] data = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentNullException>(async() => await EncryptionHelpers.EncryptDataAsync(data, null));
}
public void CreateEncryptionKey_WithInvalidSpecifiedKeySize_Throws(int keySize)
{
Assert.Throws <CryptographicException>(() => EncryptionHelpers.CreateEncryptionKey(keySize));
}
public async Task DecryptDataAsync_WithNullData_Throws()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentNullException>(async() => await EncryptionHelpers.DecryptDataAsync(null, key));
}
public async Task DecryptDataAsync_WithEmptyData_Throws()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await EncryptionHelpers.DecryptDataAsync(Array.Empty <byte>(), key));
}
public async Task GetDecryptionStreamAsync_WithNullStream_Throws()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentNullException>(async() => await EncryptionHelpers.GetDecryptionStreamAsync(key, null));
}
public async Task GetDecryptionStreamAsync_WithNonReadableStream_Throws()
{
byte[] key = EncryptionHelpers.CreateEncryptionKey();
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => await EncryptionHelpers.GetDecryptionStreamAsync(key, new NonReadableStream()));
}