/// <inheritdoc /> /// <inheritdoc cref="DisposableBase.ThrowIfDisposed"/> /// <exception cref="ArgumentException">Throws if the argument is empty</exception> public async Task AppendAsync(ISafeBytes safeBytes) { ThrowIfDisposed(); if (safeBytes.Length == 0) { throw new ArgumentException($"{nameof(safeBytes)} is empty."); } // If it's the known SafeBytes then it reveals nothing in the memory if (safeBytes is SafeBytes asSafeBytes) { var allBytes = await asSafeBytes._safeByteCollection.GetAllAsync() .ConfigureAwait(false); await _safeByteCollection.AppendManyAsync(allBytes) .ConfigureAwait(false); foreach (var safeByte in allBytes) { UpdateHashCode(safeByte); } } // If it's not, then reveals each byte in memory. else { var plainBytes = await safeBytes.RevealDecryptedBytesAsync() .ConfigureAwait(false); var stream = new SafeMemoryStream(plainBytes); await AppendManyAsync(stream).ConfigureAwait(false); } }
public async Task GetHashCode_AppendedByCombinedMethods_ReturnsSame() { // Arrange var bytes = new byte[] { 5, 10, 15 }; using var first = GetSut(); await first.AppendAsync(bytes[0]); var safeBytes = GetSut(); await safeBytes.AppendAsync(bytes[1]); await first.AppendAsync(safeBytes); var stream = new SafeMemoryStream(new[] { bytes[2] }); await first.AppendManyAsync(stream); var second = GetSut(); stream = new SafeMemoryStream(bytes); await second.AppendManyAsync(stream); // Act var hashFirst = first.GetHashCode(); var hashSecond = second.GetHashCode(); // Assert Assert.AreEqual(hashFirst, hashSecond); }
public async Task EqualsAsync_10KBSameSafeBytes_TakesLessThan200ms() { // Arrange const int expectedHigherLimit = 200; const int totalBytes = 10000; await SafeOrbitCore.Current.StartEarlyAsync(); var bytes = new byte[totalBytes]; new Random().NextBytes(bytes); var sut = GetSut(); var stream = new SafeMemoryStream(bytes.CopyToNewArray()); await sut.AppendManyAsync(stream); var other = new SafeBytes(); stream = new SafeMemoryStream(bytes); await other.AppendManyAsync(stream); // Act var actualPerformance = await MeasureAsync( () => sut.EqualsAsync(other), 5); // Assert Assert.That(actualPerformance, Is.LessThanOrEqualTo(expectedHigherLimit)); }
/// <inheritdoc /> /// <inheritdoc cref="AppendManyAsync(ISafeByte[])"/> public async Task AppendManyAsync(SafeMemoryStream stream) { var safeBytes = await _safeByteFactory.GetByBytesAsync(stream) .ConfigureAwait(false); await AppendManyAsync(safeBytes as ISafeByte[] ?? safeBytes.ToArray()) .ConfigureAwait(false); }
public void Ctor_GivenBuffer_Clears() { // Arrange var buffer = new byte[] { 5, 10, 15, 20, 25, 30 }; // Act _ = new SafeMemoryStream(buffer); // Assert Assert.That(buffer, Is.Empty.Or.All.EqualTo(0)); }
private async Task <ISafeBytes> TransformCharToSafeBytesAsync(char c, Encoding encoding) { var bytes = _textService.GetBytes(c, encoding); var stream = new SafeMemoryStream(); await stream.WriteAsync(bytes, 0, bytes.Length) .ConfigureAwait(false); var safeBytes = _safeBytesFactory.Create(); await safeBytes.AppendManyAsync(stream).ConfigureAwait(false); return(safeBytes); }
public async Task ToByteArrayAsync_MultipleBytesAddedAtOnce_ReturnsExpected() { // Arrange byte[] expected = { 5, 10, 15 }; using var sut = GetSut(); var stream = new SafeMemoryStream(expected.CopyToNewArray()); // Act await sut.AppendManyAsync(stream); var actual = await sut.RevealDecryptedBytesAsync(); // Assert CollectionAssert.AreEqual(expected, actual); }
public void Ctor_GivenBuffer_Writes() { // Arrange var expected = new byte[] { 5, 10, 15, 20, 25, 30 }; var input = expected.CopyToNewArray(); // Act var sut = new SafeMemoryStream(input); // Assert var actual = new byte[expected.Length]; sut.Read(actual, 0, expected.Length); CollectionAssert.AreEqual(expected, actual); }
public async Task AppendManyAsync_SomeBytesAdded_CanRetrieve() { // Arrange using var sut = GetSut(); var expected = new byte[] { 5, 10, 15 }; using var stream = new SafeMemoryStream(expected.CopyToNewArray()); // Act await sut.AppendManyAsync(stream); var actual = await sut.RevealDecryptedBytesAsync(); // Assert CollectionAssert.AreEqual(expected, actual); }
public async Task EqualsAsync_SafeBytesDifferentSameBytes_ReturnsFalse() { // Arrange using var sut = GetSut(); var stream = new SafeMemoryStream(new byte[] { 1, 2, 3 }); await sut.AppendManyAsync(stream); using var other = GetSut(); stream = new SafeMemoryStream(new byte[] { 4, 5 }); await other.AppendManyAsync(stream); // Act var actual = await sut.EqualsAsync(other); // Assert Assert.IsFalse(actual); }
public async Task EqualsAsync_SafeBytesHoldingSameBytes_ReturnsTrue() { // Arrange using var sut = GetSut(); var bytes = new byte[] { 5, 10, 15 }; var stream = new SafeMemoryStream(bytes.CopyToNewArray()); await sut.AppendManyAsync(stream); using var other = GetSut(); stream = new SafeMemoryStream(bytes.CopyToNewArray()); await other.AppendManyAsync(stream); // Act var actual = await sut.EqualsAsync(other); // Assert Assert.IsTrue(actual); }
public async Task AppendManyAsync_SingleMegaByteStream_TakesLessThan5000ms() { // Arrange await SafeOrbitCore.Current.StartEarlyAsync(); const int expectedHigherLimit = 5000; var sut = GetSut(); var bytes = new byte[1000000]; new Random().NextBytes(bytes); var stream = new SafeMemoryStream(bytes); // Act var actualPerformance = await MeasureAsync(() => sut.AppendManyAsync(stream)); // Assert Assert.That(actualPerformance, Is.LessThanOrEqualTo(expectedHigherLimit)); }
public async Task GetHashCode_AppendedByByteAndMany_ReturnsSame() { // Arrange using var first = GetSut(); await first.AppendAsync(1); await first.AppendAsync(2); var second = GetSut(); var stream = new SafeMemoryStream(new byte[] { 1, 2 }); await second.AppendManyAsync(stream); // Act var hashFirst = first.GetHashCode(); var hashSecond = second.GetHashCode(); // Assert Assert.AreEqual(hashFirst, hashSecond); }
private async Task <ISafeBytes> ConvertEncodingAsync(IReadOnlySafeBytes character, Encoding sourceEncoding, Encoding destinationEncoding) { var buffer = await character.RevealDecryptedBytesAsync().ConfigureAwait(false); try { buffer = _textService.Convert(sourceEncoding, destinationEncoding, buffer); var safeBytes = _safeBytesFactory.Create(); var stream = new SafeMemoryStream(buffer); await safeBytes.AppendManyAsync(stream) .ConfigureAwait(false); return(safeBytes); } finally { Array.Clear(buffer, 0, buffer.Length); } }
/// <inheritdoc cref="DisposableBase.ThrowIfDisposed"/> public async Task <bool> EqualsAsync(IReadOnlySafeBytes other) { ThrowIfDisposed(); if (other == null || other.Length == 0) { return(Length == 0); } if (this.GetHashCode() != other.GetHashCode()) { return(false); } var otherBytes = GetOtherBytesAsync(); var ownBytes = _safeByteCollection.GetAllAsync(); await Task.WhenAll(otherBytes, ownBytes) .ConfigureAwait(false); return(AreEqual(otherBytes.Result, ownBytes.Result)); async Task <ISafeByte[]> GetOtherBytesAsync() { if (other is SafeBytes safeBytes) { // If it's the known SafeBytes then it reveals nothing in the memory var bytes = await safeBytes._safeByteCollection.GetAllAsync() .ConfigureAwait(false); return(bytes); } else { // If it's not, then reveals each byte in memory. var bytes = await other.RevealDecryptedBytesAsync().ConfigureAwait(false); var stream = new SafeMemoryStream(bytes); var safe = await _safeByteFactory.GetByBytesAsync(stream) .ConfigureAwait(false); return(safe.ToArray()); } } }
public async Task ToByteArrayAsync_1MBBytes_TakesLessThan_2000ms() { // Arrange const int expectedHigherLimit = 2000; const int totalBytes = 1000000; await SafeOrbitCore.Current.StartEarlyAsync(); var sut = GetSut(); var bytes = new byte[totalBytes]; new Random().NextBytes(bytes); var stream = new SafeMemoryStream(bytes); await sut.AppendManyAsync(stream); // Act var actualPerformance = await MeasureAsync( () => sut.RevealDecryptedBytesAsync(), 5); // Assert Assert.That(actualPerformance, Is.LessThanOrEqualTo(expectedHigherLimit)); }
public async Task AppendManyAsync_MultipleBytes_AppendsToInternalCollection() { // Arrange const byte firstByte = 55, secondByte = 77; var expected = Stubs.Get <ISafeBytes>(); var stream = new SafeMemoryStream(new [] { firstByte, secondByte }); await expected.AppendManyAsync(stream); var collection = Stubs.Get <ISafeByteCollection>(); using var sut = GetSut(collection: collection); // Act await sut.AppendAsync(expected); // Assert var actual = await collection.GetAllAsync(); Assert.AreEqual(2, actual.Length); Assert.AreEqual(firstByte, actual.ElementAt(0).RevealDecryptedByteAsync().Result); Assert.AreEqual(secondByte, actual.ElementAt(1).RevealDecryptedByteAsync().Result); }
/// <inheritdoc cref="DisposableBase.ThrowIfDisposed"/> public async Task <bool> EqualsAsync(byte[] other) { ThrowIfDisposed(); if (other == null || !other.Any()) { return(Length == 0); } var otherBytes = GetOtherBytes(); var ownBytes = _safeByteCollection.GetAllAsync(); await Task.WhenAll(otherBytes, ownBytes) .ConfigureAwait(false); return(AreEqual(otherBytes.Result, ownBytes.Result)); async Task <ISafeByte[]> GetOtherBytes() { var stream = new SafeMemoryStream(other.CopyToNewArray()); var bytes = await _safeByteFactory.GetByBytesAsync(stream).ConfigureAwait(false); return(bytes.ToArray()); } }