public async Task TestForEach() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { ActiveFile activeFile; activeFile = new ActiveFile(New <IDataStore>(_encrypted1AxxPath), New <IDataStore>(_decrypted1TxtPath), new LogOnIdentity("passphrase1"), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); activeFile = new ActiveFile(New <IDataStore>(_encrypted2AxxPath), New <IDataStore>(_decrypted2TxtPath), new LogOnIdentity("passphrase2"), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); activeFile = new ActiveFile(New <IDataStore>(_encrypted3AxxPath), New <IDataStore>(_decrypted3TxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); Assert.That(state.ActiveFiles.Count(), Is.EqualTo(3), "There should be three."); int i = 0; await state.ForEach((ActiveFile activeFileArgument) => { ++i; return(Task.FromResult(activeFileArgument)); }); Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files."); i = 0; await state.ForEach((ActiveFile activeFileArgument) => { ++i; return(Task.FromResult(new ActiveFile(activeFileArgument, activeFile.Status | ActiveFileStatus.Error))); }); Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files."); } }
public static void TestDecryptedActiveFiles() { using (FileSystemState state = new FileSystemState()) { state.Load(OS.Current.FileInfo(_mystateXmlPath)); ActiveFile decryptedFile1 = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null); state.Add(decryptedFile1); ActiveFile decryptedFile2 = new ActiveFile(OS.Current.FileInfo(_encrypted2AxxPath), OS.Current.FileInfo(_decrypted2TxtPath), new AesKey(), ActiveFileStatus.DecryptedIsPendingDelete, null); state.Add(decryptedFile2); ActiveFile notDecryptedFile = new ActiveFile(OS.Current.FileInfo(_encrypted3AxxPath), OS.Current.FileInfo(_decrypted3TxtPath), new AesKey(), ActiveFileStatus.NotDecrypted, null); state.Add(notDecryptedFile); ActiveFile errorFile = new ActiveFile(OS.Current.FileInfo(_encrypted4AxxPath), OS.Current.FileInfo(_decrypted4TxtPath), new AesKey(), ActiveFileStatus.Error, null); state.Add(errorFile); IList <ActiveFile> decryptedFiles = state.DecryptedActiveFiles; Assert.That(decryptedFiles.Count, Is.EqualTo(2), "There should be two decrypted files."); Assert.That(decryptedFiles.Contains(decryptedFile1), "A file marked as AssumedOpenAndDecrypted should be found."); Assert.That(decryptedFiles.Contains(decryptedFile2), "A file marked as DecryptedIsPendingDelete should be found."); Assert.That(decryptedFiles.Contains(notDecryptedFile), Is.Not.True, "A file marked as NotDecrypted should not be found."); } }
public virtual async Task <FileOperationContext> OpenAndLaunchApplication(IEnumerable <LogOnIdentity> identities, IDataStore encryptedDataStore, IProgressContext progress) { if (identities == null) { throw new ArgumentNullException(nameof(identities)); } if (encryptedDataStore == null) { throw new ArgumentNullException(nameof(encryptedDataStore)); } if (progress == null) { throw new ArgumentNullException(nameof(progress)); } if (!encryptedDataStore.IsAvailable) { if (Resolve.Log.IsWarningEnabled) { Resolve.Log.LogWarning("Tried to open non-existing '{0}'.".InvariantFormat(encryptedDataStore.FullName)); } return(new FileOperationContext(encryptedDataStore.FullName, ErrorStatus.FileDoesNotExist)); } ActiveFile activeFile = _fileSystemState.FindActiveFileFromEncryptedPath(encryptedDataStore.FullName); if (activeFile == null || !activeFile.DecryptedFileInfo.IsAvailable) { activeFile = TryDecryptToActiveFile(encryptedDataStore, identities); } else { activeFile = CheckKeysForAlreadyDecryptedFile(activeFile, identities, progress); } if (activeFile == null) { return(new FileOperationContext(encryptedDataStore.FullName, ErrorStatus.InvalidKey)); } using (FileLock destinationLock = New <FileLocker>().Acquire(activeFile.DecryptedFileInfo)) { if (!activeFile.DecryptedFileInfo.IsAvailable) { activeFile = Decrypt(activeFile.Identity, activeFile.EncryptedFileInfo, destinationLock, activeFile, progress); } _fileSystemState.Add(activeFile); await _fileSystemState.Save(); if (encryptedDataStore.IsWriteProtected || !New <LicensePolicy>().Capabilities.Has(LicenseCapability.EditExistingFiles)) { activeFile.DecryptedFileInfo.IsWriteProtected = true; } FileOperationContext status = await LaunchApplicationForDocument(activeFile, destinationLock); return(status); } }
public static void TestForEach() { bool changedEventWasRaised = false; using (FileSystemState state = new FileSystemState()) { state.Load(OS.Current.FileInfo(_mystateXmlPath)); state.Changed += ((object sender, ActiveFileChangedEventArgs e) => { changedEventWasRaised = true; }); ActiveFile activeFile; activeFile = new ActiveFile(OS.Current.FileInfo(_encrypted1AxxPath), OS.Current.FileInfo(_decrypted1TxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null); state.Add(activeFile); activeFile = new ActiveFile(OS.Current.FileInfo(_encrypted2AxxPath), OS.Current.FileInfo(_decrypted2TxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null); state.Add(activeFile); activeFile = new ActiveFile(OS.Current.FileInfo(_encrypted3AxxPath), OS.Current.FileInfo(_decrypted3TxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null); state.Add(activeFile); Assert.That(changedEventWasRaised, Is.True, "The change event should have been raised by the adding of active files."); changedEventWasRaised = false; Assert.That(state.ActiveFiles.Count(), Is.EqualTo(3), "There should be three."); int i = 0; state.ForEach(ChangedEventMode.RaiseOnlyOnModified, (ActiveFile activeFileArgument) => { ++i; return(activeFileArgument); }); Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files."); Assert.That(changedEventWasRaised, Is.False, "No change event should have been raised."); i = 0; state.ForEach(ChangedEventMode.RaiseAlways, (ActiveFile activeFileArgument) => { ++i; return(activeFileArgument); }); Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files."); Assert.That(changedEventWasRaised, Is.True, "The change event should have been raised."); changedEventWasRaised = false; i = 0; state.ForEach(ChangedEventMode.RaiseAlways, (ActiveFile activeFileArgument) => { ++i; return(new ActiveFile(activeFileArgument, activeFile.Status | ActiveFileStatus.Error)); }); Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files."); Assert.That(changedEventWasRaised, Is.True, "The change event should have been raised."); } }
public static void DecryptAndOpenFile(IRuntimeFileInfo encryptedDocument, Passphrase passphrase, ProgressContext progress, Action <string, ProgressContext> failure = null) { string tempPath = Path.GetTempPath(); string decryptedFileName; lastUsedKey = passphrase.DerivedPassphrase; if (!TryDecrypt(encryptedDocument, tempPath, lastUsedKey, progress, out decryptedFileName)) { failure("Could not open file", progress); return; } string fullPathToDecryptedFile = Path.Combine(tempPath, decryptedFileName); IRuntimeFileInfo decryptedFile = OS.Current.FileInfo(fullPathToDecryptedFile); NSDictionary userInfo = new NSDictionary(Launcher.TargetFileUserInfoKey, decryptedFile.FullName); NSNotification notification = NSNotification.FromName(Launcher.FileDecryptedNotification, new NSObject(), userInfo); NSNotificationCenter.DefaultCenter.PostNotification(notification); ILauncher launcher = OS.Current.Launch(fullPathToDecryptedFile); launcher.Exited += (sender, e) => { fileSystemState.CheckActiveFiles(ChangedEventMode.RaiseOnlyOnModified, new ProgressContext()); }; fileSystemState.Add(new ActiveFile(encryptedDocument, decryptedFile, lastUsedKey, ActiveFileStatus.AssumedOpenAndDecrypted, launcher)); //fileSystemState.Save (); }
public static FileOperationStatus OpenAndLaunchApplication(this FileSystemState fileSystemState, string file, IEnumerable <AesKey> keys, ProgressContext progress) { if (fileSystemState == null) { throw new ArgumentNullException("fileSystemState"); } if (file == null) { throw new ArgumentNullException("file"); } if (keys == null) { throw new ArgumentNullException("keys"); } if (progress == null) { throw new ArgumentNullException("progress"); } IRuntimeFileInfo fileInfo = OS.Current.FileInfo(file); if (!fileInfo.Exists) { if (OS.Log.IsWarningEnabled) { OS.Log.LogWarning("Tried to open non-existing '{0}'.".InvariantFormat(fileInfo.FullName)); } return(FileOperationStatus.FileDoesNotExist); } ActiveFile destinationActiveFile = fileSystemState.FindEncryptedPath(fileInfo.FullName); if (destinationActiveFile == null || !destinationActiveFile.DecryptedFileInfo.Exists) { IRuntimeFileInfo destinationFolderInfo = GetTemporaryDestinationFolder(destinationActiveFile); destinationActiveFile = TryDecrypt(fileInfo, destinationFolderInfo, keys, progress); } else { destinationActiveFile = CheckKeysForAlreadyDecryptedFile(destinationActiveFile, keys, progress); } if (destinationActiveFile == null) { return(FileOperationStatus.InvalidKey); } fileSystemState.Add(destinationActiveFile); fileSystemState.Save(); FileOperationStatus status = LaunchApplicationForDocument(fileSystemState, destinationActiveFile); return(status); }
private Task <FileOperationContext> EncryptFileWorkOneAsync(IDataStore file, IProgressContext progress) { FileOperationsController controller = EncryptFileWorkController(progress); controller.Completed += (object sender, FileOperationEventArgs e) => { if (e.Status.ErrorStatus == ErrorStatus.Success) { IDataStore encryptedInfo = New <IDataStore>(e.SaveFileFullName); IDataStore decryptedInfo = New <IDataStore>(FileOperation.GetTemporaryDestinationName(e.OpenFileFullName)); ActiveFile activeFile = new ActiveFile(encryptedInfo, decryptedInfo, e.LogOnIdentity, ActiveFileStatus.NotDecrypted, e.CryptoId); _fileSystemState.Add(activeFile); } if (e.Status.ErrorStatus == ErrorStatus.FileAlreadyEncrypted) { e.Status = new FileOperationContext(string.Empty, ErrorStatus.Success); } }; return(controller.EncryptFileAsync(file)); }
private static FileOperationStatus LaunchApplicationForDocument(FileSystemState fileSystemState, ActiveFile destinationActiveFile) { ILauncher process; try { if (OS.Log.IsInfoEnabled) { OS.Log.LogInfo("Starting process for '{0}'".InvariantFormat(destinationActiveFile.DecryptedFileInfo.FullName)); } process = OS.Current.Launch(destinationActiveFile.DecryptedFileInfo.FullName); if (process.WasStarted) { process.Exited += new EventHandler(process_Exited); } else { if (OS.Log.IsInfoEnabled) { OS.Log.LogInfo("Starting process for '{0}' did not start a process, assumed handled by the shell.".InvariantFormat(destinationActiveFile.DecryptedFileInfo.FullName)); } } } catch (Win32Exception w32ex) { if (OS.Log.IsErrorEnabled) { OS.Log.LogError("Could not launch application for '{0}', Win32Exception was '{1}'.".InvariantFormat(destinationActiveFile.DecryptedFileInfo.FullName, w32ex.Message)); } return(FileOperationStatus.CannotStartApplication); } if (OS.Log.IsWarningEnabled) { if (process.HasExited) { OS.Log.LogWarning("The process seems to exit immediately for '{0}'".InvariantFormat(destinationActiveFile.DecryptedFileInfo.FullName)); } } if (OS.Log.IsInfoEnabled) { OS.Log.LogInfo("Launched and opened '{0}'.".InvariantFormat(destinationActiveFile.DecryptedFileInfo.FullName)); } destinationActiveFile = new ActiveFile(destinationActiveFile, ActiveFileStatus.AssumedOpenAndDecrypted, process); fileSystemState.Add(destinationActiveFile); fileSystemState.Save(); return(FileOperationStatus.Success); }
public void TestFindEncryptedPath() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { ActiveFile activeFile = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); ActiveFile byEncryptedPath = state.FindActiveFileFromEncryptedPath(_encryptedAxxPath); Assert.That(byEncryptedPath.EncryptedFileInfo.FullName, Is.EqualTo(_encryptedAxxPath), "The search should return the same path."); ActiveFile notFoundEncrypted = state.FindActiveFileFromEncryptedPath(Path.Combine(_rootPath, "notfoundfile.txt")); Assert.That(notFoundEncrypted, Is.Null, "A search that does not succeed should return null."); } }
public void TestDecryptedActiveFiles() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { ActiveFile decryptedFile1 = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase1"), ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); state.Add(decryptedFile1); ActiveFile decryptedFile2 = new ActiveFile(New <IDataStore>(_encrypted2AxxPath), New <IDataStore>(_decrypted2TxtPath), new LogOnIdentity("passphrase2"), ActiveFileStatus.DecryptedIsPendingDelete, new V1Aes128CryptoFactory().CryptoId); state.Add(decryptedFile2); ActiveFile notDecryptedFile = new ActiveFile(New <IDataStore>(_encrypted3AxxPath), New <IDataStore>(_decrypted3TxtPath), new LogOnIdentity("passphrase3"), ActiveFileStatus.NotDecrypted, new V1Aes128CryptoFactory().CryptoId); state.Add(notDecryptedFile); ActiveFile errorFile = new ActiveFile(New <IDataStore>(_encrypted4AxxPath), New <IDataStore>(_decrypted4TxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.Error, new V1Aes128CryptoFactory().CryptoId); state.Add(errorFile); IList <ActiveFile> decryptedFiles = state.DecryptedActiveFiles; Assert.That(decryptedFiles.Count, Is.EqualTo(2), "There should be two decrypted files."); Assert.That(decryptedFiles.Contains(decryptedFile1), "A file marked as AssumedOpenAndDecrypted should be found."); Assert.That(decryptedFiles.Contains(decryptedFile2), "A file marked as DecryptedIsPendingDelete should be found."); Assert.That(decryptedFiles.Contains(notDecryptedFile), Is.Not.True, "A file marked as NotDecrypted should not be found."); } }
public async Task TestStatusMaskAtLoad() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { FakeDataStore.AddFile(_encryptedAxxPath, FakeDataStore.TestDate1Utc, FakeDataStore.TestDate2Utc, FakeDataStore.TestDate3Utc, new MemoryStream(Resources.helloworld_key_a_txt)); ActiveFile activeFile = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); await state.Save(); FileSystemState reloadedState = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt")); Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated."); Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(1), "The reloaded state should have one active file."); Assert.That(reloadedState.ActiveFiles.First().Status, Is.EqualTo(ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.NoProcessKnown), "When reloading saved state, some statuses should be masked away and NoProcessKnown added."); } }
public static void TestStatusMaskAtLoad() { using (FileSystemState state = new FileSystemState()) { state.Load(OS.Current.FileInfo(_mystateXmlPath)); ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null); state.Add(activeFile); state.Save(); FileSystemState reloadedState = new FileSystemState(); reloadedState.Load(OS.Current.FileInfo(_mystateXmlPath)); Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated."); Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(1), "The reloaded state should have one active file."); Assert.That(reloadedState.ActiveFiles.First().Status, Is.EqualTo(ActiveFileStatus.AssumedOpenAndDecrypted), "When reloading saved state, some statuses should be masked away."); } }
public void TestArgumentNull() { using (FileSystemState state = new FileSystemState()) { ActiveFile nullActiveFile = null; string nullPath = null; Func <ActiveFile, Task <ActiveFile> > nullAction = null; IDataStore nullFileInfo = null; Assert.Throws <ArgumentNullException>(() => { state.RemoveActiveFile(nullActiveFile); }); Assert.Throws <ArgumentNullException>(() => { state.Add(nullActiveFile); }); Assert.Throws <ArgumentNullException>(() => { state.FindActiveFileFromEncryptedPath(nullPath); }); Assert.ThrowsAsync <ArgumentNullException>(async() => { await state.ForEach(nullAction); }); Assert.Throws <ArgumentNullException>(() => { FileSystemState.Create(nullFileInfo); }); } }
public static void TestArgumentNull() { using (FileSystemState state = new FileSystemState()) { ActiveFile nullActiveFile = null; string nullPath = null; Func <ActiveFile, ActiveFile> nullAction = null; IRuntimeFileInfo nullFileInfo = null; Assert.Throws <ArgumentNullException>(() => { state.Remove(nullActiveFile); }); Assert.Throws <ArgumentNullException>(() => { state.Add(nullActiveFile); }); Assert.Throws <ArgumentNullException>(() => { state.FindEncryptedPath(nullPath); }); Assert.Throws <ArgumentNullException>(() => { state.FindDecryptedPath(nullPath); }); Assert.Throws <ArgumentNullException>(() => { state.ForEach(ChangedEventMode.RaiseAlways, nullAction); }); Assert.Throws <ArgumentNullException>(() => { state.Load(nullFileInfo); }); } }
public static void TestFileContainedByActiveFilesButNotDecrypted() { IEnumerable <AesKey> keys = new AesKey[] { new Passphrase("a").DerivedPassphrase }; FileOperationStatus status = _fileSystemState.OpenAndLaunchApplication(_helloWorldAxxPath, keys, new ProgressContext()); Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The launch should succeed."); IRuntimeFileInfo fileInfo = OS.Current.FileInfo(_helloWorldAxxPath); ActiveFile destinationActiveFile = _fileSystemState.FindEncryptedPath(fileInfo.FullName); destinationActiveFile.DecryptedFileInfo.Delete(); destinationActiveFile = new ActiveFile(destinationActiveFile, ActiveFileStatus.NotDecrypted); _fileSystemState.Add(destinationActiveFile); _fileSystemState.Save(); status = _fileSystemState.OpenAndLaunchApplication(_helloWorldAxxPath, keys, new ProgressContext()); Assert.That(status, Is.EqualTo(FileOperationStatus.Success), "The launch should once again succeed."); }
public async Task TestWatchedFolderChanged() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { FakeDataStore.AddFolder(_rootPath); await state.AddWatchedFolderAsync(new WatchedFolder(_rootPath, IdentityPublicTag.Empty)); Assert.That(state.ActiveFileCount, Is.EqualTo(0)); FakeDataStore.AddFile(_encryptedAxxPath, new MemoryStream(Resources.helloworld_key_a_txt)); Assert.That(state.ActiveFileCount, Is.EqualTo(0)); state.Add(new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.NotDecrypted, new V1Aes128CryptoFactory().CryptoId)); Assert.That(state.ActiveFileCount, Is.EqualTo(1)); New <IDataStore>(_encryptedAxxPath).Delete(); Assert.That(state.ActiveFileCount, Is.EqualTo(0), "When deleted, the active file count should be zero."); } }
public static void TestChangedEvent() { using (FileSystemState state = new FileSystemState()) { state.Load(OS.Current.FileInfo(_mystateXmlPath)); bool wasHere; state.Changed += new EventHandler <ActiveFileChangedEventArgs>((object sender, ActiveFileChangedEventArgs e) => { wasHere = true; }); ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null); wasHere = false; state.Add(activeFile); Assert.That(state.ActiveFiles.Count(), Is.EqualTo(1), "After the Add() the state should have one active file."); Assert.That(wasHere, Is.True, "After the Add(), the changed event should have been raised."); wasHere = false; state.Remove(activeFile); Assert.That(wasHere, Is.True, "After the Remove(), the changed event should have been raised."); Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "After the Remove() the state should have no active files."); } }
public async Task TestLoadExistingWithNonExistingFile() { ActiveFile activeFile; using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(state, Is.Not.Null, "An instance should always be instantiated."); Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "A new state should not have any active files."); activeFile = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); await state.Save(); } using (FileSystemState reloadedState = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated."); Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(0), "The reloaded state should not have an active file, since it is non-existing."); } }
public static void TestFindEncryptedAndDecryptedPath() { using (FileSystemState state = new FileSystemState()) { state.Load(OS.Current.FileInfo(_mystateXmlPath)); ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null); state.Add(activeFile); ActiveFile byDecryptedPath = state.FindDecryptedPath(_decryptedTxtPath); Assert.That(byDecryptedPath, Is.EqualTo(activeFile), "The search should return the same instance."); ActiveFile byEncryptedPath = state.FindEncryptedPath(_encryptedAxxPath); Assert.That(byEncryptedPath, Is.EqualTo(byDecryptedPath), "The search should return the same instance."); ActiveFile notFoundEncrypted = state.FindEncryptedPath(Path.Combine(_rootPath, "notfoundfile.txt")); Assert.That(notFoundEncrypted, Is.Null, "A search that does not succeed should return null."); ActiveFile notFoundDecrypted = state.FindDecryptedPath(Path.Combine(_rootPath, "notfoundfile.txt")); Assert.That(notFoundDecrypted, Is.Null, "A search that does not succeed should return null."); } }
public static FileOperationStatus OpenAndLaunchApplication(this FileSystemState fileSystemState, string file, AxCryptDocument document, ProgressContext progress) { if (fileSystemState == null) { throw new ArgumentNullException("fileSystemState"); } if (file == null) { throw new ArgumentNullException("file"); } if (document == null) { throw new ArgumentNullException("document"); } if (progress == null) { throw new ArgumentNullException("progress"); } IRuntimeFileInfo fileInfo = OS.Current.FileInfo(file); ActiveFile destinationActiveFile = fileSystemState.FindEncryptedPath(fileInfo.FullName); if (destinationActiveFile == null || !destinationActiveFile.DecryptedFileInfo.Exists) { IRuntimeFileInfo destinationFolderInfo = GetTemporaryDestinationFolder(destinationActiveFile); destinationActiveFile = DecryptActiveFileDocument(fileInfo, destinationFolderInfo, document, progress); } else { destinationActiveFile = new ActiveFile(destinationActiveFile, document.DocumentHeaders.KeyEncryptingKey); } fileSystemState.Add(destinationActiveFile); fileSystemState.Save(); FileOperationStatus status = LaunchApplicationForDocument(fileSystemState, destinationActiveFile); return(status); }
public void TestInvalidJson() { string badJson = @"{abc:1{}"; IDataStore stateInfo = Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"); using (Stream stream = stateInfo.OpenWrite()) { byte[] bytes = Encoding.UTF8.GetBytes(badJson); stream.Write(bytes, 0, bytes.Length); } using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(state.ActiveFileCount, Is.EqualTo(0), "After loading damaged state, the count should be zero."); ActiveFile decryptedFile1 = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); state.Add(decryptedFile1); Assert.That(state.ActiveFileCount, Is.EqualTo(1), "After adding a file, the count should be one."); } }
public static void TestInvalidXml() { string badXml = @"<FileSystemState xmlns=""http://www.axantum.com/Serialization/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">"; IRuntimeFileInfo stateInfo = OS.Current.FileInfo(_mystateXmlPath); using (Stream stream = stateInfo.OpenWrite()) { byte[] bytes = Encoding.UTF8.GetBytes(badXml); stream.Write(bytes, 0, bytes.Length); } using (FileSystemState state = new FileSystemState()) { Assert.DoesNotThrow(() => state.Load(stateInfo)); Assert.That(state.ActiveFileCount, Is.EqualTo(0), "After loading damaged state, the count should be zero."); ActiveFile decryptedFile1 = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null); state.Add(decryptedFile1); Assert.That(state.ActiveFileCount, Is.EqualTo(1), "After adding a file, the count should be one."); } }
public async Task TestLoadExistingWithExistingFile() { ActiveFile activeFile; using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(state, Is.Not.Null, "An instance should always be instantiated."); Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "A new state should not have any active files."); activeFile = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); state.Add(activeFile); await state.Save(); } FakeDataStore.AddFile(_encryptedAxxPath, FakeDataStore.TestDate1Utc, FakeDataStore.TestDate2Utc, FakeDataStore.TestDate3Utc, Stream.Null); using (FileSystemState reloadedState = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated."); Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(1), "The reloaded state should have one active file."); Assert.That(reloadedState.ActiveFiles.First().ThumbprintMatch(activeFile.Identity.Passphrase), Is.True, "The reloaded thumbprint should match the key."); } }
public static void TestLoadExisting() { ActiveFile activeFile; using (FileSystemState state = new FileSystemState()) { state.Load(OS.Current.FileInfo(_mystateXmlPath)); Assert.That(state, Is.Not.Null, "An instance should always be instantiated."); Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "A new state should not have any active files."); activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null); state.Add(activeFile); state.Save(); } using (FileSystemState reloadedState = new FileSystemState()) { reloadedState.Load(OS.Current.FileInfo(_mystateXmlPath)); Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated."); Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(1), "The reloaded state should have one active file."); Assert.That(reloadedState.ActiveFiles.First().ThumbprintMatch(activeFile.Key), Is.True, "The reloaded thumbprint should match the key."); } }
public static void TestCheckActiveFilesIsNotLocked() { DateTime utcNow = OS.Current.UtcNow; DateTime utcYesterday = utcNow.AddDays(-1); FakeRuntimeFileInfo.AddFile(_encryptedFile1, utcNow, utcNow, utcNow, Stream.Null); FakeRuntimeFileInfo.AddFile(_decryptedFile1, utcYesterday, utcYesterday, utcYesterday, Stream.Null); ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), new AesKey(), ActiveFileStatus.NotDecrypted, null); SetupAssembly.FakeRuntimeEnvironment.TimeFunction = (() => { return(utcNow.AddMinutes(10)); }); bool changedWasRaised = false; _fileSystemState.Add(activeFile); _fileSystemState.Changed += ((object sender, ActiveFileChangedEventArgs e) => { changedWasRaised = true; }); _fileSystemState.CheckActiveFiles(ChangedEventMode.RaiseOnlyOnModified, new ProgressContext()); Assert.That(changedWasRaised, Is.True, "The file should be detected as decrypted being created."); }