public void TestDecryptCompressedWithTruncatedFile()
{
Passphrase passphrase = new Passphrase("Å ä Ö");
using (V1AxCryptDocument document = new V1AxCryptDocument())
{
using (MemoryStream encryptedFile = FakeDataStore.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt))
{
encryptedFile.SetLength(encryptedFile.Length / 2);
encryptedFile.Position = 0;
bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, encryptedFile);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
Assert.That(() => { document.DecryptTo(plaintextStream); }, Throws.InstanceOf <Exception>());
}
}
}
}
/// <summary>
/// Tries to load a key pair from the serialized byte array.
/// </summary>
/// <param name="value">The bytes.</param>
/// <param name="passphrase">The passphrase.</param>
/// <param name="keyPair">The key pair.</param>
/// <returns>True if the pair was successfully loaded, and set in the keyPair parameter.</returns>
public static bool TryLoad(byte[] value, Passphrase passphrase, out UserKeyPair keyPair)
{
using (MemoryStream encryptedStream = new MemoryStream(value))
{
using (MemoryStream decryptedStream = new MemoryStream())
{
EncryptedProperties properties = New <AxCryptFile>().Decrypt(encryptedStream, decryptedStream, new DecryptionParameter[] { new DecryptionParameter(passphrase, Resolve.CryptoFactory.Preferred.CryptoId) });
if (!properties.IsValid)
{
keyPair = null;
return(false);
}
string json = Encoding.UTF8.GetString(decryptedStream.ToArray(), 0, (int)decryptedStream.Length);
keyPair = Resolve.Serializer.Deserialize <UserKeyPair>(json);
return(true);
}
}
}
public void TestDecryptCompressedFromLargerFile()
{
Passphrase passphrase = new Passphrase("Å ä Ö");
using (V1AxCryptDocument document = new V1AxCryptDocument())
{
bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, FakeDataStore.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt));
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream);
string text = Encoding.UTF8.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length);
Assert.That(text.StartsWith("The Project Gutenberg EBook of David Copperfield, by Charles Dickens"), "Unexpected start of David Copperfield.");
Assert.That(text.EndsWith("subscribe to our email newsletter to hear about new eBooks." + (Char)13 + (Char)10), "Unexpected end of David Copperfield.");
Assert.That(text.Length, Is.EqualTo(1992490), "Wrong length of full text of David Copperfield.");
Assert.That(document.DocumentHeaders.PlaintextLength, Is.EqualTo(795855), "Wrong expected length of compressed text of David Copperfield.");
}
}
}
public static void TestDecryptCompressedWithCancel()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("Å ä Ö");
bool keyIsOk = document.Load(FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt), passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
ProgressContext progress = new ProgressContext(TimeSpan.Zero);
progress.Progressing += (object sender, ProgressEventArgs e) =>
{
throw new OperationCanceledException();
};
Assert.Throws <OperationCanceledException>(() => { document.DecryptTo(plaintextStream, progress); });
}
}
}
public static void TestHmac()
{
using (Stream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt))
{
using (AxCryptReader axCryptReader = new AxCryptStreamReader(inputStream))
{
Assert.Throws <InvalidOperationException>(() =>
{
if (axCryptReader.Hmac == null)
{
}
}, "The reader is not positioned properly to get the HMAC.");
Passphrase passphrase = new Passphrase("a");
DocumentHeaders documentHeaders = new DocumentHeaders(passphrase.DerivedPassphrase);
bool keyIsOk = documentHeaders.Load(axCryptReader);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (Stream encrypedDataStream = axCryptReader.CreateEncryptedDataStream(documentHeaders.HmacSubkey.Key, documentHeaders.CipherTextLength, new ProgressContext()))
{
Assert.Throws <InvalidOperationException>(() =>
{
if (axCryptReader.Hmac == null)
{
}
}, "We have not read the encrypted data yet.");
Assert.That(axCryptReader.Read(), Is.False, "The reader should be at end of stream now, and Read() should return false.");
encrypedDataStream.CopyTo(Stream.Null, 4096);
Assert.That(documentHeaders.Hmac, Is.EqualTo(axCryptReader.Hmac), "The HMAC should be correct.");
axCryptReader.Dispose();
Assert.Throws <ObjectDisposedException>(() =>
{
DataHmac disposedHmac = axCryptReader.Hmac;
Object.Equals(disposedHmac, null);
}, "The reader is disposed.");
}
}
}
}
public async Task TestWatchedFoldersWhenLoggedOn()
{
Passphrase key1 = new Passphrase("a");
LogOnIdentity key2 = new LogOnIdentity("b");
KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify);
FakeDataStore.AddFolder(@"C:\WatchedFolder1\");
FakeDataStore.AddFolder(@"C:\WatchedFolder2\");
await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder1\", new LogOnIdentity(key1).Tag));
await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder2\", key2.Tag));
await knownIdentities.SetDefaultEncryptionIdentity(key2);
IEnumerable <WatchedFolder> watchedFolders = knownIdentities.LoggedOnWatchedFolders;
Assert.That(watchedFolders.Count(), Is.EqualTo(1), "Only one of the two watched folders should be shown.");
Assert.That(watchedFolders.First().Tag.Matches(key2.Tag), "The returned watched folder should be number 2.");
}
public static void TestSimpleEncryptToWithoutCompression()
{
DateTime creationTimeUtc = new DateTime(2012, 1, 1, 1, 2, 3, DateTimeKind.Utc);
DateTime lastAccessTimeUtc = creationTimeUtc + new TimeSpan(1, 0, 0);
DateTime lastWriteTimeUtc = creationTimeUtc + new TimeSpan(2, 0, 0);;
using (Stream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!")))
{
using (Stream outputStream = new MemoryStream())
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
DocumentHeaders headers = new DocumentHeaders(passphrase.DerivedPassphrase);
headers.FileName = "MyFile.txt";
headers.CreationTimeUtc = creationTimeUtc;
headers.LastAccessTimeUtc = lastAccessTimeUtc;
headers.LastWriteTimeUtc = lastWriteTimeUtc;
document.DocumentHeaders = headers;
document.EncryptTo(headers, inputStream, outputStream, AxCryptOptions.EncryptWithoutCompression, new ProgressContext());
}
outputStream.Position = 0;
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
bool keyIsOk = document.Load(outputStream, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
Assert.That(document.DocumentHeaders.FileName, Is.EqualTo("MyFile.txt"));
Assert.That(document.DocumentHeaders.CreationTimeUtc, Is.EqualTo(creationTimeUtc));
Assert.That(document.DocumentHeaders.LastAccessTimeUtc, Is.EqualTo(lastAccessTimeUtc));
Assert.That(document.DocumentHeaders.LastWriteTimeUtc, Is.EqualTo(lastWriteTimeUtc));
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream, new ProgressContext());
Assert.That(document.DocumentHeaders.UncompressedLength, Is.EqualTo(-1), "'AxCrypt is Great!' should not return a value at all for uncompressed, since it was not compressed.");
Assert.That(document.DocumentHeaders.PlaintextLength, Is.EqualTo(17), "'AxCrypt is Great!' is 17 bytes plaintext length.");
Assert.That(Encoding.ASCII.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length), Is.EqualTo("AxCrypt is Great!"), "Unexpected result of decryption.");
}
}
}
}
}
public async Task TestLogOnExistingIdentity()
{
Passphrase passphrase = new Passphrase("p");
Passphrase id = passphrase;
Resolve.FileSystemState.KnownPassphrases.Add(id);
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
e.Passphrase = new Passphrase("p");
return(Task.FromResult <object>(null));
};
await ivm.LogOnLogOff.ExecuteAsync(null);
Assert.That(Resolve.KnownIdentities.IsLoggedOn);
}
public async Task AskForLogOnPassphraseWithKnownIdentityButWrongPassphraseEntered()
{
Passphrase passphrase = new Passphrase("aaa");
Passphrase id = passphrase;
Resolve.FileSystemState.KnownPassphrases.Add(id);
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
e.Passphrase = new Passphrase("bbb");
return(Task.FromResult <object>(null));
};
await ivm.AskForLogOnPassphrase.ExecuteAsync(null);
Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty);
Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1));
}
public async Task <bool> ChangePassphraseAsync(Passphrase passphrase)
{
if (New <AxCryptOnlineState>().IsOnline)
{
try
{
return(await _remoteService.ChangePassphraseAsync(passphrase).Free());
}
catch (UnauthorizedException uaex)
{
New <IReport>().Exception(uaex);
return(false);
}
catch (ApiException aex)
{
await aex.HandleApiExceptionAsync();
}
}
return(await _localService.ChangePassphraseAsync(passphrase).Free());
}
/// <summary>
/// Loads an AxCrypt file from the specified reader. After this, the reader is positioned to
/// read encrypted data.
/// </summary>
/// <param name="passphrase">The passphrase.</param>
/// <param name="cryptoId">The crypto identifier.</param>
/// <param name="reader">The reader.</param>
/// <param name="headers">The headers.</param>
/// <returns>
/// True if the key was valid, false if it was wrong.
/// </returns>
private bool Load(Passphrase passphrase, Guid cryptoId, AxCryptReader reader, Headers headers)
{
ResetState();
if (cryptoId == new V1Aes128CryptoFactory().CryptoId)
{
return(PassphraseIsValid);
}
_reader = reader;
CryptoFactory = Resolve.CryptoFactory.Create(cryptoId);
V2KeyWrapHeaderBlock keyWrap = headers.FindHeaderBlock <V2KeyWrapHeaderBlock>();
IDerivedKey key = CryptoFactory.RestoreDerivedKey(passphrase, keyWrap.DerivationSalt, keyWrap.DerivationIterations);
keyWrap.SetDerivedKey(CryptoFactory, key);
DocumentHeaders = new V2DocumentHeaders(keyWrap);
PassphraseIsValid = DocumentHeaders.Load(headers);
Properties = EncryptedProperties.Create(this);
return(PassphraseIsValid);
}
public static void TestCheckActiveFilesKeyIsNotSetWithoutKnownKey()
{
DateTime utcNow = OS.Current.UtcNow;
FakeRuntimeFileInfo.AddFile(_encryptedFile1, utcNow, utcNow, utcNow, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt));
Passphrase passphrase = new Passphrase("a");
AxCryptFile.Decrypt(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), passphrase.DerivedPassphrase, AxCryptOptions.None, new ProgressContext());
ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), passphrase.DerivedPassphrase, ActiveFileStatus.AssumedOpenAndDecrypted, null);
_fileSystemState.Add(activeFile);
_fileSystemState.Save();
_fileSystemState.Dispose();
_fileSystemState = new FileSystemState();
_fileSystemState.Load(OS.Current.FileInfo(_fileSystemStateFilePath));
IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_decryptedFile1);
decryptedFileInfo.SetFileTimes(utcNow.AddSeconds(30), utcNow.AddSeconds(30), utcNow.AddSeconds(30));
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = (() => { return(utcNow.AddMinutes(1)); });
bool changedWasRaised = false;
_fileSystemState.Changed += ((object sender, ActiveFileChangedEventArgs e) =>
{
changedWasRaised = true;
});
activeFile = _fileSystemState.FindEncryptedPath(_encryptedFile1);
Assert.That(activeFile.Key, Is.Null, "The key should be null after loading of new FileSystemState");
_fileSystemState.CheckActiveFiles(ChangedEventMode.RaiseOnlyOnModified, new ProgressContext());
Assert.That(changedWasRaised, Is.False, "The ActiveFile should be not be modified because the file was modified as well and thus cannot be deleted.");
activeFile = _fileSystemState.FindEncryptedPath(_encryptedFile1);
Assert.That(activeFile.Key, Is.Null, "The key should still be null after the checking of active files.");
Assert.That(activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted), Is.True, "The file should still be there.");
Assert.That(activeFile.ThumbprintMatch(passphrase.DerivedPassphrase), Is.True, "The active file should still be known to be decryptable with the original passphrase.");
}
private static string DecryptPrivateKeyPem(string privateEncryptedPem, Passphrase passphrase)
{
if (privateEncryptedPem.Length == 0)
{
return(String.Empty);
}
byte[] privateKeyEncryptedPem = Convert.FromBase64String(privateEncryptedPem);
byte[] decryptedPrivateKeyBytes = New <IProtectedData>().Unprotect(privateKeyEncryptedPem, null);
if (decryptedPrivateKeyBytes != null)
{
return(Encoding.UTF8.GetString(decryptedPrivateKeyBytes, 0, decryptedPrivateKeyBytes.Length));
}
if (passphrase == Passphrase.Empty)
{
return(null);
}
using (MemoryStream encryptedPrivateKeyStream = new MemoryStream(privateKeyEncryptedPem))
{
using (MemoryStream decryptedPrivateKeyStream = new MemoryStream())
{
DecryptionParameter decryptionParameter = new DecryptionParameter(passphrase, Resolve.CryptoFactory.Preferred.CryptoId);
try
{
if (!New <AxCryptFile>().Decrypt(encryptedPrivateKeyStream, decryptedPrivateKeyStream, new DecryptionParameter[] { decryptionParameter }).IsValid)
{
return(null);
}
}
catch (FileFormatException ffex)
{
New <IReport>().Exception(ffex);
return(null);
}
return(Encoding.UTF8.GetString(decryptedPrivateKeyStream.ToArray(), 0, (int)decryptedPrivateKeyStream.Length));
}
}
}
private async Task ImportFileActionAsync()
{
IDataStore privateKeyData = New <IDataStore>(PrivateKeyFileName);
Passphrase passphrase = new Passphrase(PasswordText);
UserKeyPair keyPair;
if (!UserKeyPair.TryLoad(privateKeyData.ToArray(), passphrase, out keyPair))
{
ImportSuccessful = false;
return;
}
LogOnIdentity identity = new LogOnIdentity(keyPair.UserEmail, passphrase);
AccountStorage store = new AccountStorage(New <LogOnIdentity, IAccountService>(identity));
await store.ImportAsync(keyPair);
ImportSuccessful = true;
_userSettings.UserEmail = keyPair.UserEmail.Address;
await _knownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity(await store.AllKeyPairsAsync(), passphrase));
}
public async Task AskForNewLogOnPassphraseAutomaticallyBecauseNoIdentitiesExists()
{
Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Create("aaa"));
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
e.Passphrase = new Passphrase("aaa");
e.Name = "New User Passphrase";
return(Task.FromResult <object>(null));
};
await ivm.AskForLogOnPassphrase.ExecuteAsync(LogOnIdentity.Empty);
Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa"));
Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(new Passphrase("aaa").Thumbprint));
Passphrase id = Resolve.FileSystemState.KnownPassphrases.FirstOrDefault(i => i.Thumbprint == new Passphrase("aaa").Thumbprint);
Assert.That(id.Thumbprint, Is.EqualTo(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint));
}
public async Task TestLogOnLogOffWhenLoggedOffAndNoIdentities()
{
bool wasCreateNew = true;
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
wasCreateNew = e.IsAskingForPreviouslyUnknownPassphrase;
e.Passphrase = new Passphrase("ccc");
e.Name = "New User Passphrase";
return(Task.FromResult <object>(null));
};
Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Create("ccc"));
await ivm.LogOnLogOff.ExecuteAsync(null);
Assert.That(wasCreateNew, Is.False, "Logging on event should not be with Create New set.");
Assert.That(Resolve.KnownIdentities.IsLoggedOn, Is.True, "Should be logged on.");
Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(new Passphrase("ccc").Thumbprint));
Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1));
}
public void TestDecryptCompressedWithCancel()
{
Passphrase passphrase = new Passphrase("Å ä Ö");
using (V1AxCryptDocument document = new V1AxCryptDocument())
{
IProgressContext progress = new CancelProgressContext(new ProgressContext(new TimeSpan(0, 0, 0, 0, 100)));
bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, new ProgressStream(FakeDataStore.ExpandableMemoryStream(Resources.david_copperfield_key__aa_ae_oe__ulu_txt), progress));
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
progress.Progressing += (object sender, ProgressEventArgs e) =>
{
progress.Cancel = true;
};
FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current;
environment.CurrentTiming.CurrentTiming = new TimeSpan(0, 0, 0, 0, 100);
Assert.Throws <OperationCanceledException>(() => { document.DecryptTo(plaintextStream); });
}
}
}
public async Task AskForLogOnPassphraseWithKnownIdentity()
{
Passphrase passphrase = new Passphrase("aaa");
Passphrase id = passphrase;
Resolve.FileSystemState.KnownPassphrases.Add(id);
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
e.Passphrase = new Passphrase("aaa");
return(Task.FromResult <object>(null));
};
await ivm.AskForLogOnPassphrase.ExecuteAsync(null);
Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa"));
Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(passphrase.Thumbprint));
Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1));
}
private bool EncryptFilePreparation(string fullName)
{
if (String.Compare(Path.GetExtension(fullName), OS.Current.AxCryptExtension, StringComparison.OrdinalIgnoreCase) == 0)
{
_eventArgs.Status = FileOperationStatus.FileAlreadyEncrypted;
return(false);
}
IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(fullName);
IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(AxCryptFile.MakeAxCryptFileName(sourceFileInfo));
_eventArgs.SaveFileFullName = destinationFileInfo.FullName;
_eventArgs.OpenFileFullName = fullName;
if (destinationFileInfo.Exists)
{
OnQuerySaveFileAs(_eventArgs);
if (_eventArgs.Cancel)
{
_eventArgs.Status = FileOperationStatus.Canceled;
return(false);
}
}
if (_fileSystemState.KnownKeys.DefaultEncryptionKey == null)
{
OnQueryEncryptionPassphrase(_eventArgs);
if (_eventArgs.Cancel)
{
_eventArgs.Status = FileOperationStatus.Canceled;
return(false);
}
Passphrase passphrase = new Passphrase(_eventArgs.Passphrase);
_eventArgs.Key = passphrase.DerivedPassphrase;
}
else
{
_eventArgs.Key = _fileSystemState.KnownKeys.DefaultEncryptionKey;
}
return(true);
}
public static void TestDecryptUncompressedWithPaddingError()
{
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
using (MemoryStream encryptedFile = FakeRuntimeFileInfo.ExpandableMemoryStream((byte[])Resources.helloworld_key_a_txt.Clone()))
{
encryptedFile.Seek(-1, SeekOrigin.End);
byte lastByte = (byte)encryptedFile.ReadByte();
++lastByte;
encryptedFile.Seek(-1, SeekOrigin.End);
encryptedFile.WriteByte(lastByte);
encryptedFile.Position = 0;
bool keyIsOk = document.Load(encryptedFile, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
Assert.Throws <CryptographicException>(() => { document.DecryptTo(plaintextStream, new ProgressContext()); });
}
}
}
}
private async Task <LogOnIdentity> AddKnownIdentityFromEventAsync(LogOnEventArgs logOnArgs)
{
if (logOnArgs.Cancel || logOnArgs.Passphrase == Passphrase.Empty)
{
return(LogOnIdentity.Empty);
}
_userSettings.DisplayEncryptPassphrase = logOnArgs.DisplayPassphrase;
Passphrase passphrase = logOnArgs.Passphrase;
LogOnIdentity identity = await LogOnIdentityFromCredentialsAsync(EmailAddress.Parse(logOnArgs.UserEmail), passphrase);
if (identity == LogOnIdentity.Empty)
{
identity = new LogOnIdentity(passphrase);
_fileSystemState.KnownPassphrases.Add(passphrase);
await _fileSystemState.Save();
}
await _knownIdentities.AddAsync(identity);
return(identity);
}
/// <summary>
/// Loads an AxCrypt file from the specified reader. After this, the reader is positioned to
/// read encrypted data.
/// </summary>
/// <param name="inputStream">The stream to read from. Will be disposed when this instance is disposed.</param>
/// <returns>True if the key was valid, false if it was wrong.</returns>
private bool Load(Passphrase passphrase, AxCryptReader reader, Headers headers)
{
_reader = reader;
ResetState(passphrase);
PassphraseIsValid = DocumentHeaders.Load(headers);
if (!PassphraseIsValid)
{
return(false);
}
_hmacStream = new V1HmacStream(DocumentHeaders.HmacSubkey.Key);
foreach (HeaderBlock header in DocumentHeaders.Headers.HeaderBlocks)
{
if (header.HeaderBlockType != HeaderBlockType.Preamble)
{
header.Write(_hmacStream);
}
}
Properties = EncryptedProperties.Create(this);
return(true);
}
public void TestSimpleEncryptToWithCompression()
{
DateTime creationTimeUtc = new DateTime(2012, 1, 1, 1, 2, 3, DateTimeKind.Utc);
DateTime lastAccessTimeUtc = creationTimeUtc + new TimeSpan(1, 0, 0);
DateTime lastWriteTimeUtc = creationTimeUtc + new TimeSpan(2, 0, 0);;
using (Stream inputStream = FakeDataStore.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!")))
{
using (Stream outputStream = new MemoryStream())
{
Passphrase passphrase = new Passphrase("a");
using (V1AxCryptDocument document = new V1AxCryptDocument(passphrase, 47))
{
document.DocumentHeaders.FileName = "MyFile.txt";
document.DocumentHeaders.CreationTimeUtc = creationTimeUtc;
document.DocumentHeaders.LastAccessTimeUtc = lastAccessTimeUtc;
document.DocumentHeaders.LastWriteTimeUtc = lastWriteTimeUtc;
document.EncryptTo(inputStream, outputStream, AxCryptOptions.EncryptWithCompression);
}
outputStream.Position = 0;
using (V1AxCryptDocument document = new V1AxCryptDocument())
{
bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, outputStream);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
Assert.That(document.DocumentHeaders.FileName, Is.EqualTo("MyFile.txt"));
Assert.That(document.DocumentHeaders.CreationTimeUtc, Is.EqualTo(creationTimeUtc));
Assert.That(document.DocumentHeaders.LastAccessTimeUtc, Is.EqualTo(lastAccessTimeUtc));
Assert.That(document.DocumentHeaders.LastWriteTimeUtc, Is.EqualTo(lastWriteTimeUtc));
using (MemoryStream plaintextStream = new MemoryStream())
{
document.DecryptTo(plaintextStream);
Assert.That(document.DocumentHeaders.UncompressedLength, Is.EqualTo(17), "'AxCrypt is Great!' should be 17 bytes uncompressed plaintext.");
Assert.That(Encoding.ASCII.GetString(plaintextStream.GetBuffer(), 0, (int)plaintextStream.Length), Is.EqualTo("AxCrypt is Great!"), "Unexpected result of decryption.");
}
}
}
}
}
public V1DocumentHeaders(Passphrase passphrase, long keyWrapIterations)
: this(passphrase)
{
_headers.HeaderBlocks.Add(new PreambleHeaderBlock());
_headers.HeaderBlocks.Add(new VersionHeaderBlock(_version));
_headers.HeaderBlocks.Add(new V1KeyWrap1HeaderBlock(_keyEncryptingKey.DerivedKey, keyWrapIterations));
ICrypto headerCrypto = Resolve.CryptoFactory.Legacy.CreateCrypto(HeadersSubkey.Key, null, 0);
_headers.HeaderBlocks.Add(new V1EncryptionInfoEncryptedHeaderBlock(headerCrypto));
_headers.HeaderBlocks.Add(new V1CompressionEncryptedHeaderBlock(headerCrypto));
_headers.HeaderBlocks.Add(new FileInfoEncryptedHeaderBlock(headerCrypto));
_headers.HeaderBlocks.Add(new V1UnicodeFileNameInfoEncryptedHeaderBlock(headerCrypto));
_headers.HeaderBlocks.Add(new V1FileNameInfoEncryptedHeaderBlock(headerCrypto));
_headers.HeaderBlocks.Add(new DataHeaderBlock());
SetMasterKeyForEncryptedHeaderBlocks(_headers.HeaderBlocks);
V1EncryptionInfoEncryptedHeaderBlock encryptionInfoHeaderBlock = _headers.FindHeaderBlock <V1EncryptionInfoEncryptedHeaderBlock>();
encryptionInfoHeaderBlock.IV = new SymmetricIV(128);
encryptionInfoHeaderBlock.PlaintextLength = 0;
FileName = String.Empty;
}
public static void TestDecryptWithCancel()
{
IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
using (AxCryptDocument document = new AxCryptDocument())
{
Passphrase passphrase = new Passphrase("a");
using (Stream sourceStream = sourceFileInfo.OpenRead())
{
bool keyIsOk = document.Load(sourceStream, passphrase.DerivedPassphrase);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(_rootPath.PathCombine("Destination", "Decrypted.txt"));
ProgressContext progress = new ProgressContext(TimeSpan.Zero);
progress.Progressing += (object sender, ProgressEventArgs e) =>
{
throw new OperationCanceledException();
};
Assert.Throws <OperationCanceledException>(() => { AxCryptFile.Decrypt(document, destinationInfo, AxCryptOptions.None, progress); });
}
}
}
public void TestDecryptUncompressedWithPaddingError()
{
Passphrase passphrase = new Passphrase("a");
using (V1AxCryptDocument document = new V1AxCryptDocument())
{
using (MemoryStream encryptedFile = FakeDataStore.ExpandableMemoryStream((byte[])Resources.helloworld_key_a_txt.Clone()))
{
encryptedFile.Seek(-1, SeekOrigin.End);
byte lastByte = (byte)encryptedFile.ReadByte();
++lastByte;
encryptedFile.Seek(-1, SeekOrigin.End);
encryptedFile.WriteByte(lastByte);
encryptedFile.Position = 0;
bool keyIsOk = document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, encryptedFile);
Assert.That(keyIsOk, Is.True, "The passphrase provided is correct!");
using (MemoryStream plaintextStream = new MemoryStream())
{
Assert.Throws <CryptoException>(() => { document.DecryptTo(plaintextStream); });
}
}
}
}
protected override async Task ProcessRequestAsync(IHttpWebRequest request, Dictionary <string, object> payload)
{
if (CanMakeAuthenticatedRequest(payload))
{
if (payload.TryGetValue("body", out var body))
{
payload.Remove("body");
}
var nonce = payload["nonce"].ToString();
payload.Remove("nonce");
var json = JsonConvert.SerializeObject(body ?? payload);
if (json == "{}")
{
json = "";
}
var passphrase = Passphrase?.ToUnsecureString();
if (string.IsNullOrEmpty(passphrase))
{
passphrase = PrivateApiKey?.ToUnsecureString();
}
var hexSha384 = CryptoUtility.SHA384Sign(
$"{request.RequestUri.PathAndQuery.Replace("/spot", string.Empty)}{nonce}{json}",
passphrase);
request.AddHeader("btse-sign", hexSha384);
request.AddHeader("btse-nonce", nonce);
request.AddHeader("btse-api", PublicApiKey.ToUnsecureString());
await request.WriteToRequestAsync(json);
}
await base.ProcessRequestAsync(request, payload);
}
public async Task <Result> Restore(Passphrase passphrase)
{
var keyPair = new KeyPair
(
PublicKey,
new PrivateKey(backup.EncryptedPrivateKey)
);
if (IsInCache)
{
Debug.Assert(passphrase != null);
if (!keyPair.CanUnlockWith(passphrase))
{
return(false);
}
}
var identity = await Engine.ImportIdentity(backup.Stereotype, Name, keyPair);
Main.CurrentIdentity = (IdentityVM)identity;
return(true);
}
public async Task AskForNewLogOnPassphraseWithCancel()
{
Passphrase defaultPassphrase = null;
Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Empty);
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
bool isCancelling = false;
ivm.LoggingOnAsync = (e) =>
{
if (isCancelling)
{
e.Cancel = true;
return(Task.FromResult <object>(null));
}
if (!e.IsAskingForPreviouslyUnknownPassphrase)
{
e.IsAskingForPreviouslyUnknownPassphrase = true;
e.Passphrase = new Passphrase("xxx");
return(Task.FromResult <object>(null));
}
defaultPassphrase = e.Passphrase;
e.Cancel = isCancelling = true;
return(Task.FromResult <object>(null));
};
await ivm.AskForLogOnPassphrase.ExecuteAsync(null);
Assert.That(defaultPassphrase, Is.EqualTo(new Passphrase("xxx")));
Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity == LogOnIdentity.Empty);
Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty);
Passphrase id = Resolve.FileSystemState.KnownPassphrases.FirstOrDefault(i => i.Thumbprint == new Passphrase("xxx").Thumbprint);
Assert.That(id, Is.Null);
}
public void TestHmacThrowsWhenTooLittleData()
{
using (MemoryStream plaintext = new MemoryStream(Resources.uncompressable_zip))
{
MemoryStream encryptedFile = new MemoryStream();
using (V1AxCryptDocument encryptingDocument = new V1AxCryptDocument(new Passphrase("a"), 10))
{
encryptingDocument.EncryptTo(plaintext, encryptedFile, AxCryptOptions.EncryptWithoutCompression);
}
encryptedFile.Position = 0;
Headers headers = new Headers();
AxCryptReader reader = headers.CreateReader(new LookAheadStream(encryptedFile));
using (V1AxCryptDocument document = new V1AxCryptDocument(reader))
{
Passphrase key = new Passphrase("a");
bool keyIsOk = document.Load(key, new V1Aes128CryptoFactory().CryptoId, headers);
Assert.That(keyIsOk, Is.True);
reader.InputStream.Read(new byte[16], 0, 16);
Assert.Throws <InvalidOperationException>(() => document.DecryptTo(Stream.Null));
}
}
}
