public static void TestSimpleEncryptFile()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
string destinationPath = String.Empty;
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.Passphrase = "allan";
};
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
FileOperationStatus status = controller.EncryptFile(_davidCopperfieldTxtPath);
Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
Assert.That(destinationInfo.Exists, "After encryption the destination file should be created.");
using (AxCryptDocument document = new AxCryptDocument())
{
using (Stream stream = destinationInfo.OpenRead())
{
document.Load(stream, new Passphrase("allan").DerivedPassphrase);
Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given.");
}
}
}
public static void TestWipeWithConfirmAll()
{
ProgressContext progress = new ProgressContext();
FileOperationsController controller = new FileOperationsController(_fileSystemState, progress);
int confirmationCount = 0;
controller.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
{
if (confirmationCount++ > 0)
{
throw new InvalidOperationException("The event should not be raised a second time.");
}
e.ConfirmAll = true;
};
progress.NotifyLevelStart();
FileOperationStatus status = controller.WipeFile(_helloWorldAxxPath);
Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The wipe should indicate success.");
IRuntimeFileInfo fileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
Assert.That(!fileInfo.Exists, "The file should not exist after wiping.");
Assert.DoesNotThrow(() => { status = controller.WipeFile(_davidCopperfieldTxtPath); });
Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The wipe should indicate success.");
progress.NotifyLevelFinished();
fileInfo = OS.Current.FileInfo(_davidCopperfieldTxtPath);
Assert.That(!fileInfo.Exists, "The file should not exist after wiping.");
}
public static void TestEncryptFileThatIsAlreadyEncrypted()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
FileOperationStatus status = controller.EncryptFile("test" + OS.Current.AxCryptExtension);
Assert.That(status, Is.EqualTo(FileOperationStatus.FileAlreadyEncrypted), "The status should indicate that it was already encrypted.");
}
public static void TestSimpleWipeOnThreadWorker()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
controller.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
{
e.Cancel = false;
e.Skip = false;
e.ConfirmAll = false;
};
string destinationPath = String.Empty;
FileOperationStatus status = FileOperationStatus.Unknown;
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
status = e.Status;
};
using (ThreadWorker worker = new ThreadWorker(new ProgressContext()))
{
controller.WipeFile(_davidCopperfieldTxtPath, worker);
}
Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
Assert.That(!destinationInfo.Exists, "After wiping the destination file should not exist.");
}
public async Task TestSimpleDecryptAndLaunch()
{
FakeLauncher launcher = new FakeLauncher();
bool called = false;
TypeMap.Register.New <ILauncher>(() => { called = true; return(launcher); });
FileOperationsController controller = new FileOperationsController();
controller.QueryDecryptionPassphrase = (FileOperationEventArgs e) =>
{
e.LogOnIdentity = new LogOnIdentity("a");
return(Task.FromResult <object>(null));
};
FileOperationContext status = await controller.DecryptAndLaunchAsync(New <IDataStore>(_helloWorldAxxPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
Assert.That(called, Is.True, "There should be a call to launch.");
Assert.That(Path.GetFileName(launcher.Path), Is.EqualTo("HelloWorld-Key-a.txt"), "The file should be decrypted and the name should be the original from the encrypted headers.");
IDataStore destinationInfo = New <IDataStore>(launcher.Path);
Assert.That(destinationInfo.IsAvailable, "After decryption the destination file should be created.");
string fileContent;
using (Stream stream = destinationInfo.OpenRead())
{
fileContent = new StreamReader(stream).ReadToEnd();
}
Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
}
public static void TestDecryptFileWithExceptionBeforeStartingDecryption()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.Passphrase = "a";
};
controller.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
{
throw new FileNotFoundException("Just kidding, but we're faking...", e.OpenFileFullName);
};
string destinationPath = String.Empty;
controller.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
FileOperationStatus status = FileOperationStatus.Unknown;
Assert.DoesNotThrow(() => { status = controller.DecryptFile(_helloWorldAxxPath); });
Assert.That(status, Is.EqualTo(FileOperationStatus.FileDoesNotExist), "The status should indicate an exception occurred.");
Assert.That(String.IsNullOrEmpty(destinationPath), "Since an exception occurred, the destination file should not be created.");
}
public async Task TestEncryptFileThatIsAlreadyEncrypted()
{
FileOperationsController controller = new FileOperationsController();
FileOperationContext status = await controller.EncryptFileAsync(New <IDataStore>("test" + OS.Current.AxCryptExtension));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.FileAlreadyEncrypted), "The status should indicate that it was already encrypted.");
}
public void TestDecryptFileWithExceptionBeforeStartingDecryption()
{
FileOperationsController controller = new FileOperationsController();
controller.QueryDecryptionPassphrase = (FileOperationEventArgs e) =>
{
e.LogOnIdentity = new LogOnIdentity("a");
return(Task.FromResult <object>(null));
};
controller.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>((FileOperationEventArgs e) =>
{
throw new FileNotFoundException("Just kidding, but we're faking...", e.OpenFileFullName);
});
string destinationPath = String.Empty;
AsyncDelegateAction <FileOperationEventArgs> previous = controller.KnownKeyAdded;
controller.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>(async(FileOperationEventArgs e) =>
{
await previous.ExecuteAsync(e);
destinationPath = e.SaveFileFullName;
});
FileOperationContext status = new FileOperationContext(String.Empty, ErrorStatus.Unknown);
Assert.DoesNotThrowAsync(async() => { status = await controller.DecryptFileAsync(New <IDataStore>(_helloWorldAxxPath)); });
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.FileDoesNotExist), "The status should indicate an exception occurred.");
Assert.That(String.IsNullOrEmpty(destinationPath), "Since an exception occurred, the destination file should not be created.");
}
private Task <FileOperationContext> VerifyAndAddActiveWorkAsync(IDataStore fullName, IProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(progress);
operationsController.QueryDecryptionPassphrase += HandleQueryDecryptionPassphraseEventAsync;
operationsController.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>(async(FileOperationEventArgs e) =>
{
if (!_fileSystemState.KnownPassphrases.Any(i => i.Thumbprint == e.LogOnIdentity.Passphrase.Thumbprint))
{
_fileSystemState.KnownPassphrases.Add(e.LogOnIdentity.Passphrase);
}
await _knownIdentities.AddAsync(e.LogOnIdentity);
});
operationsController.Completed += (object sender, FileOperationEventArgs e) =>
{
if (e.Status.ErrorStatus == ErrorStatus.Success)
{
IDataStore encryptedInfo = New <IDataStore>(e.OpenFileFullName);
IDataStore decryptedInfo = New <IDataStore>(FileOperation.GetTemporaryDestinationName(e.SaveFileFullName));
ActiveFile activeFile = new ActiveFile(encryptedInfo, decryptedInfo, e.LogOnIdentity, ActiveFileStatus.NotDecrypted, e.CryptoId);
_fileSystemState.Add(activeFile);
}
};
return(operationsController.VerifyEncryptedAsync(fullName));
}
public static void TestEncryptFileWithDefaultEncryptionKey()
{
_fileSystemState.KnownKeys.DefaultEncryptionKey = new Passphrase("default").DerivedPassphrase;
FileOperationsController controller = new FileOperationsController(_fileSystemState);
bool queryEncryptionPassphraseWasCalled = false;
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
queryEncryptionPassphraseWasCalled = true;
};
string destinationPath = String.Empty;
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
FileOperationStatus status = controller.EncryptFile(_davidCopperfieldTxtPath);
Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
Assert.That(!queryEncryptionPassphraseWasCalled, "No query of encryption passphrase should be needed since there is a default set.");
IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
Assert.That(destinationInfo.Exists, "After encryption the destination file should be created.");
using (AxCryptDocument document = new AxCryptDocument())
{
using (Stream stream = destinationInfo.OpenRead())
{
document.Load(stream, new Passphrase("default").DerivedPassphrase);
Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the default passphrase given.");
}
}
}
public void TestSimpleWipeOnThreadWorker()
{
FileOperationsController controller = new FileOperationsController();
controller.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
{
e.Cancel = false;
e.Skip = false;
e.ConfirmAll = false;
};
string destinationPath = String.Empty;
FileOperationContext status = new FileOperationContext(String.Empty, ErrorStatus.Unknown);
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
status = e.Status;
};
controller.WipeFileAsync(New <IDataStore>(_davidCopperfieldTxtPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
IDataStore destinationInfo = New <IDataStore>(destinationPath);
Assert.That(!destinationInfo.IsAvailable, "After wiping the destination file should not exist.");
}
private Task <FileOperationContext> OpenEncryptedWorkAsync(IDataStore file, IProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(progress);
operationsController.QueryDecryptionPassphrase = HandleQueryOpenPassphraseEventAsync;
operationsController.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>(async(FileOperationEventArgs e) =>
{
if (!_fileSystemState.KnownPassphrases.Any(i => i.Thumbprint == e.LogOnIdentity.Passphrase.Thumbprint))
{
_fileSystemState.KnownPassphrases.Add(e.LogOnIdentity.Passphrase);
}
await _knownIdentities.AddAsync(e.LogOnIdentity);
});
operationsController.SetConvertLegacyOptionCommandAsync = async() =>
{
if (Resolve.UserSettings.EncryptionUpgradeMode != EncryptionUpgradeMode.NotDecided)
{
return;
}
if (!New <LicensePolicy>().Capabilities.Has(LicenseCapability.EditExistingFiles))
{
return;
}
bool autoConvert = await New <IPopup>().ShowAsync(PopupButtons.OkCancel, Texts.OptionsConvertMenuItemText, Texts.LegacyOpenMessage) == PopupButtons.Ok;
autoConvert = autoConvert && New <IVerifySignInPassword>().Verify(Texts.LegacyConversionVerificationPrompt);
New <UserSettings>().EncryptionUpgradeMode = autoConvert ? EncryptionUpgradeMode.AutoUpgrade : EncryptionUpgradeMode.RetainWithoutUpgrade;
};
return(operationsController.DecryptAndLaunchAsync(file));
}
public async Task TestWipeWithConfirmAll()
{
ProgressContext progress = new ProgressContext();
FileOperationsController controller = new FileOperationsController(progress);
int confirmationCount = 0;
controller.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
{
if (confirmationCount++ > 0)
{
throw new InvalidOperationException("The event should not be raised a second time.");
}
e.ConfirmAll = true;
};
progress.NotifyLevelStart();
FileOperationContext status = await controller.WipeFileAsync(New <IDataStore>(_helloWorldAxxPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The wipe should indicate success.");
IDataStore fileInfo = New <IDataStore>(_helloWorldAxxPath);
Assert.That(!fileInfo.IsAvailable, "The file should not exist after wiping.");
Assert.DoesNotThrowAsync(async() => { status = await controller.WipeFileAsync(New <IDataStore>(_davidCopperfieldTxtPath)); });
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The wipe should indicate success.");
progress.NotifyLevelFinished();
fileInfo = New <IDataStore>(_davidCopperfieldTxtPath);
Assert.That(!fileInfo.IsAvailable, "The file should not exist after wiping.");
}
private Task <FileOperationContext> WipeFileWorkAsync(IDataStore file, IProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(progress);
operationsController.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
{
FileSelectionEventArgs fileSelectionArgs = new FileSelectionEventArgs(new string[] { file.FullName, })
{
FileSelectionType = FileSelectionType.WipeConfirm,
};
OnSelectingFiles(fileSelectionArgs);
e.Cancel = fileSelectionArgs.Cancel;
e.Skip = fileSelectionArgs.Skip;
e.ConfirmAll = fileSelectionArgs.ConfirmAll;
e.SaveFileFullName = fileSelectionArgs.SelectedFiles.FirstOrDefault() ?? String.Empty;
};
operationsController.Completed += async(object sender, FileOperationEventArgs e) =>
{
if (e.Skip)
{
return;
}
if (e.Status.ErrorStatus == ErrorStatus.Success)
{
await New <ActiveFileAction>().RemoveRecentFiles(new IDataStore[] { New <IDataStore>(e.SaveFileFullName) }, progress);
}
};
return(operationsController.WipeFileAsync(file));
}
public async Task TestSimpleEncryptFile()
{
FileOperationsController controller = new FileOperationsController();
string destinationPath = String.Empty;
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.LogOnIdentity = new LogOnIdentity("allan");
};
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
FileOperationContext status = await controller.EncryptFileAsync(New <IDataStore>(_davidCopperfieldTxtPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
IDataStore destinationInfo = New <IDataStore>(destinationPath);
Assert.That(destinationInfo.IsAvailable, "After encryption the destination file should be created.");
using (V2AxCryptDocument document = new V2AxCryptDocument())
{
using (Stream stream = destinationInfo.OpenRead())
{
document.Load(new Passphrase("allan"), new V2Aes256CryptoFactory().CryptoId, stream);
Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given.");
}
}
}
private void EncryptFile(string file, IThreadWorker worker, ProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);
operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
sfd.Title = Resources.EncryptFileSaveAsDialogTitle;
sfd.AddExtension = true;
sfd.ValidateNames = true;
sfd.CheckPathExists = true;
sfd.DefaultExt = OS.Current.AxCryptExtension;
sfd.FileName = e.SaveFileFullName;
sfd.Filter = Resources.EncryptedFileDialogFilterPattern.InvariantFormat(OS.Current.AxCryptExtension);
sfd.InitialDirectory = Path.GetDirectoryName(e.SaveFileFullName);
sfd.ValidateNames = true;
DialogResult saveAsResult = sfd.ShowDialog();
if (saveAsResult != DialogResult.OK)
{
e.Cancel = true;
return;
}
e.SaveFileFullName = sfd.FileName;
}
};
operationsController.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
string passphrase = AskForEncryptionPassphrase();
if (String.IsNullOrEmpty(passphrase))
{
e.Cancel = true;
return;
}
e.Passphrase = passphrase;
AesKey defaultEncryptionKey = new Passphrase(e.Passphrase).DerivedPassphrase;
persistentState.Current.KnownKeys.DefaultEncryptionKey = defaultEncryptionKey;
};
operationsController.Completed += (object sender, FileOperationEventArgs e) =>
{
if (e.Status == FileOperationStatus.FileAlreadyEncrypted)
{
e.Status = FileOperationStatus.Success;
return;
}
if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
{
IRuntimeFileInfo encryptedInfo = OS.Current.FileInfo(e.SaveFileFullName);
IRuntimeFileInfo decryptedInfo = OS.Current.FileInfo(FileOperation.GetTemporaryDestinationName(e.OpenFileFullName));
ActiveFile activeFile = new ActiveFile(encryptedInfo, decryptedInfo, e.Key, ActiveFileStatus.NotDecrypted, null);
persistentState.Current.Add(activeFile);
persistentState.Current.Save();
}
};
operationsController.EncryptFile(file, worker);
}
private Task <FileOperationContext> VerifyFileIntegrityAsync(IDataStore dataStore, LogOnIdentity identity, IProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(progress);
operationsController.QueryDecryptionPassphrase = HandleQueryDecryptionPassphraseEventAsync;
return(operationsController.VerifyFileIntegrityAsync(dataStore));
}
public async Task TestDecryptFileWithRepeatedPassphraseQueries()
{
FileOperationsController controller = new FileOperationsController();
int passphraseTry = 0;
controller.QueryDecryptionPassphrase = (FileOperationEventArgs e) =>
{
switch (++passphraseTry)
{
case 1:
e.LogOnIdentity = new LogOnIdentity("b");
break;
case 2:
e.LogOnIdentity = new LogOnIdentity("d");
break;
case 3:
e.LogOnIdentity = new LogOnIdentity("a");
break;
case 4:
e.LogOnIdentity = new LogOnIdentity("e");
break;
}
;
return(Task.FromResult <object>(null));
};
string destinationPath = String.Empty;
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
bool knownKeyWasAdded = false;
controller.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>((FileOperationEventArgs e) =>
{
knownKeyWasAdded = e.LogOnIdentity.Equals(new LogOnIdentity("a"));
return(Constant.CompletedTask);
});
FileOperationContext status = await controller.DecryptFileAsync(New <IDataStore>(_helloWorldAxxPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
Assert.That(knownKeyWasAdded, "A new known key was used, so the KnownKeyAdded event should have been raised.");
Assert.That(passphraseTry, Is.EqualTo(3), "The third key was the correct one.");
IDataStore destinationInfo = New <IDataStore>(destinationPath);
Assert.That(destinationInfo.IsAvailable, "After decryption the destination file should be created.");
string fileContent;
using (Stream stream = destinationInfo.OpenRead())
{
fileContent = new StreamReader(stream).ReadToEnd();
}
Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
}
public static void TestDecryptFileWithRepeatedPassphraseQueries()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
int passphraseTry = 0;
controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
switch (++passphraseTry)
{
case 1:
e.Passphrase = "b";
break;
case 2:
e.Passphrase = "d";
break;
case 3:
e.Passphrase = "a";
break;
case 4:
e.Passphrase = "e";
break;
}
;
};
string destinationPath = String.Empty;
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
bool knownKeyWasAdded = false;
controller.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
{
knownKeyWasAdded = e.Key == new Passphrase("a").DerivedPassphrase;
};
FileOperationStatus status = controller.DecryptFile(_helloWorldAxxPath);
Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The status should indicate success.");
Assert.That(knownKeyWasAdded, "A new known key was used, so the KnownKeyAdded event should have been raised.");
Assert.That(passphraseTry, Is.EqualTo(3), "The third key was the correct one.");
IRuntimeFileInfo destinationInfo = OS.Current.FileInfo(destinationPath);
Assert.That(destinationInfo.Exists, "After decryption the destination file should be created.");
string fileContent;
using (Stream stream = destinationInfo.OpenRead())
{
fileContent = new StreamReader(stream).ReadToEnd();
}
Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
}
public static void TestCanceledDecryptAndLaunch()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
controller.QueryDecryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.Cancel = true;
};
FileOperationStatus status = controller.DecryptAndLaunch(_helloWorldAxxPath);
Assert.That(status, Is.EqualTo(FileOperationStatus.Canceled), "The status should indicate cancellation.");
}
private void SelectFileToCompressButton_Click(object sender, EventArgs e)
{
FileOperationsController _selectedFileOperations = new FileOperationsController();
ReadFileController _readTextFileController = new ReadFileController();
_selectedFileOperations.selectFileDirectory();
FileNameTextBox.Text = _selectedFileOperations.getSelectedFileDirectoryName();
filePathRichBox.Text = _selectedFileOperations.getSelectedFileDirectoryPath().ToString();
UncompressedByteSizeTextBox.Text = "Bytes: " + _selectedFileOperations.getSelectedFileDirectorySize();
}
private Task <FileOperationContext> EncryptionUpgradeWorkAsync(IDataStore store, IProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(progress);
operationsController.QueryDecryptionPassphrase = HandleQueryDecryptionPassphraseEventAsync;
operationsController.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>(async(FileOperationEventArgs e) =>
{
await _knownIdentities.AddAsync(e.LogOnIdentity);
});
return(operationsController.EncryptionUpgradeAsync(store));
}
public static void TestEncryptFileWhenCanceledDuringQueryPassphrase()
{
FileOperationsController controller = new FileOperationsController(_fileSystemState);
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.Cancel = true;
};
FileOperationStatus status = controller.EncryptFile(_davidCopperfieldTxtPath);
Assert.That(status, Is.EqualTo(FileOperationStatus.Canceled), "The status should indicate cancellation.");
}
public async Task TestCanceledDecryptAndLaunch()
{
FileOperationsController controller = new FileOperationsController();
controller.QueryDecryptionPassphrase = (FileOperationEventArgs e) =>
{
e.Cancel = true;
return(Task.FromResult <object>(null));
};
FileOperationContext status = await controller.DecryptAndLaunchAsync(New <IDataStore>(_helloWorldAxxPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Canceled), "The status should indicate cancellation.");
}
public async Task TestEncryptFileWhenCanceledDuringQueryPassphrase()
{
FileOperationsController controller = new FileOperationsController();
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.Cancel = true;
};
FileOperationContext status = await controller.EncryptFileAsync(New <IDataStore>(_davidCopperfieldTxtPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Canceled), "The status should indicate cancellation.");
}
private void LZWCompressButton_Click_1(object sender, EventArgs e)
{
LZWCompress _lzwCompress = new LZWCompress(this);
IReadFileController _readTextFileController = new ReadFileController();
IFileOperationsController _fileOperationController = new FileOperationsController();
string compressedFilePath = null;
compressedFilePathRichTextBox.Text = filePathRichBox.Text.Remove(filePathRichBox.Text.Length - 4) + "Compressed.txt";
_lzwCompress.LZWCompressFile(filePathRichBox.Text, compressedFilePathRichTextBox.Text, Convert.ToInt16(selectedMaxBitSizeTextbox.Text));
compressedFilePath = filePathRichBox.Text.Remove(filePathRichBox.Text.Length - 4) + "Compressed.txt";
compressedByteSizeTextBox.Text = _fileOperationController.getFileByteSize(compressedFilePath);
}
public async Task TestEncryptFileWhenDestinationExists()
{
IDataStore sourceInfo = New <IDataStore>(_davidCopperfieldTxtPath);
IDataStore expectedDestinationInfo = New <IDataStore>(AxCryptFile.MakeAxCryptFileName(sourceInfo));
using (Stream stream = expectedDestinationInfo.OpenWrite())
{
}
FileOperationsController controller = new FileOperationsController();
string destinationPath = String.Empty;
LogOnIdentity logOnIdentity = null;
controller.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
{
e.LogOnIdentity = new LogOnIdentity("allan");
};
controller.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
{
e.SaveFileFullName = Path.Combine(Path.GetDirectoryName(e.SaveFileFullName), "alternative-name.axx");
};
Guid cryptoId = Guid.Empty;
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
logOnIdentity = e.LogOnIdentity;
cryptoId = e.CryptoId;
};
FileOperationContext status = await controller.EncryptFileAsync(New <IDataStore>(_davidCopperfieldTxtPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
Assert.That(Path.GetFileName(destinationPath), Is.EqualTo("alternative-name.axx"), "The alternative name should be used, since the default existed.");
IDataStore destinationInfo = New <IDataStore>(destinationPath);
Assert.That(destinationInfo.IsAvailable, "After encryption the destination file should be created.");
EncryptionParameters encryptionParameters = new EncryptionParameters(cryptoId, logOnIdentity);
await encryptionParameters.AddAsync(logOnIdentity.PublicKeys);
Headers headers = new Headers();
AxCryptReaderBase reader = headers.CreateReader(new LookAheadStream(destinationInfo.OpenRead()));
using (IAxCryptDocument document = AxCryptReaderBase.Document(reader))
{
document.Load(logOnIdentity.Passphrase, cryptoId, headers);
Assert.That(document.PassphraseIsValid, "The encrypted document should be valid and encrypted with the passphrase given.");
}
}
private static FileOperationsController EncryptFileWorkController(IProgressContext progress)
{
FileOperationsController operationsController = new FileOperationsController(progress);
operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
{
using (FileLock lockedSave = e.SaveFileFullName.CreateUniqueFile())
{
e.SaveFileFullName = lockedSave.DataStore.FullName;
lockedSave.DataStore.Delete();
}
};
return(operationsController);
}
private void LZWDecompressButton_Click_1(object sender, EventArgs e)
{
IFileOperationsController _fileOperationController = new FileOperationsController();
LZWDecompress _lzwDecompress = new LZWDecompress(this);
string decompressedFilePath = compressedFilePathRichTextBox.Text.Remove(compressedFilePathRichTextBox.Text.Length - 14) + "Uncompressed.txt";
decompressedFileNameTextBox.Text = decompressedFilePath;
_lzwDecompress.LZWDecompressFile(compressedFilePathRichTextBox.Text, decompressedFilePath, Convert.ToInt16(selectedMaxBitSizeTextbox.Text));
decompressedByteSizeTextBox.Text = _fileOperationController.getFileByteSize(decompressedFilePath);
compressedPercentanceTextBox.Text = _lzwDecompress.getCompressionRatio(double.Parse(compressedByteSizeTextBox.Text), double.Parse(decompressedByteSizeTextBox.Text)) + " %";
CompressedDataPercentanceTextBox.Text = (100 - Convert.ToDouble(compressedPercentanceTextBox.Text.Remove(compressedPercentanceTextBox.Text.Length - 2))).ToString() + " %";
}
public async Task TestDecryptWithKnownKey()
{
FileOperationsController controller = new FileOperationsController();
await Resolve.KnownIdentities.AddAsync(new LogOnIdentity("b"));
await Resolve.KnownIdentities.AddAsync(new LogOnIdentity("c"));
await Resolve.KnownIdentities.AddAsync(new LogOnIdentity("a"));
await Resolve.KnownIdentities.AddAsync(new LogOnIdentity("e"));
bool passphraseWasQueried = false;
controller.QueryDecryptionPassphrase = (FileOperationEventArgs e) =>
{
passphraseWasQueried = true;
return(Task.FromResult <object>(null));
};
string destinationPath = String.Empty;
controller.Completed += (object sender, FileOperationEventArgs e) =>
{
destinationPath = e.SaveFileFullName;
};
bool knownKeyWasAdded = false;
controller.KnownKeyAdded = new AsyncDelegateAction <FileOperationEventArgs>((FileOperationEventArgs e) =>
{
knownKeyWasAdded = true;
return(Constant.CompletedTask);
});
FileOperationContext status = await controller.DecryptFileAsync(New <IDataStore>(_helloWorldAxxPath));
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should indicate success.");
Assert.That(!knownKeyWasAdded, "An already known key was used, so the KnownKeyAdded event should not have been raised.");
Assert.That(!passphraseWasQueried, "An already known key was used, so the there should be no need to query for a passphrase.");
IDataStore destinationInfo = New <IDataStore>(destinationPath);
Assert.That(destinationInfo.IsAvailable, "After decryption the destination file should be created.");
string fileContent;
using (Stream stream = destinationInfo.OpenRead())
{
fileContent = new StreamReader(stream).ReadToEnd();
}
Assert.That(fileContent.Contains("Hello"), "A file named Hello World should contain that text when decrypted.");
}
