public void TestDecryptOfTooNewFileVersion() { 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, 101)) { document.FileName = "MyFile.txt"; document.CreationTimeUtc = creationTimeUtc; document.LastAccessTimeUtc = lastAccessTimeUtc; document.LastWriteTimeUtc = lastWriteTimeUtc; VersionHeaderBlock versionHeaderBlock = document.DocumentHeaders.VersionHeaderBlock; versionHeaderBlock.FileVersionMajor = (byte)(versionHeaderBlock.FileVersionMajor + 1); document.EncryptTo(inputStream, outputStream, AxCryptOptions.EncryptWithoutCompression); } outputStream.Position = 0; using (V1AxCryptDocument document = new V1AxCryptDocument()) { Assert.Throws <FileFormatException>(() => { document.Load(passphrase, new V1Aes128CryptoFactory().CryptoId, outputStream); }); } } } }
public async Task TestWatchedFolders() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(state.WatchedFolders, Is.Not.Null, "There should be a Watched Folders instance."); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(0), "There should be no Watched folders."); FakeDataStore.AddFolder(_rootPath); await state.AddWatchedFolderAsync(new WatchedFolder(_rootPath, IdentityPublicTag.Empty)); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should be one Watched Folder."); await state.AddWatchedFolderAsync(new WatchedFolder(_rootPath, IdentityPublicTag.Empty)); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should still only be one Watched Folder."); await state.Save(); } using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should be one Watched Folder."); Assert.That(state.WatchedFolders.First().Matches(_rootPath), "The Watched Folder should be equal to this."); await state.RemoveAndDecryptWatchedFolder(Resolve.WorkFolder.FileInfo.FolderItemInfo("mystate.txt")); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should still be one Watched folders."); await state.RemoveAndDecryptWatchedFolder(New <IDataContainer>(_rootPath)); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(0), "There should be no Watched folders now."); } }
public async Task TestHandleSessionEventLogOn(CryptoImplementation cryptoImplementation) { SetupAssembly.AssemblySetupCrypto(cryptoImplementation); MockAxCryptFile mock = new MockAxCryptFile(); bool called = false; int folderCount = -1; mock.EncryptFilesUniqueWithBackupAndWipeMockAsync = async(IEnumerable <IDataContainer> folderInfos, EncryptionParameters encryptionParameters, IProgressContext progress) => { folderCount = folderInfos.Count(); called = true; await Task.Delay(0); }; Mock <IStatusChecker> mockStatusChecker = new Mock <IStatusChecker>(); SessionNotificationHandler handler = new SessionNotificationHandler(Resolve.FileSystemState, Resolve.KnownIdentities, New <ActiveFileAction>(), mock, mockStatusChecker.Object); FakeDataStore.AddFolder(@"C:\WatchedFolder"); LogOnIdentity key = new LogOnIdentity("passphrase"); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder", key.Tag)); await handler.HandleNotificationAsync(new SessionNotification(SessionNotificationType.SignIn, key)); Assert.That(called, Is.True); Assert.That(folderCount, Is.EqualTo(1), "There should be one folder passed for encryption as a result of the event."); }
public async Task TestAddRemoveKnownWatchedFolder() { using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt"))) { KnownFolder knownFolder = New <IKnownFoldersDiscovery>().Discover().First(); FakeDataStore.AddFolder(knownFolder.My.FullName); await state.AddWatchedFolderAsync(new WatchedFolder(knownFolder.My.FullName, IdentityPublicTag.Empty)); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1)); Assert.That(state.AllWatchedFolders.Count(), Is.EqualTo(1)); await state.RemoveAndDecryptWatchedFolder(knownFolder.My); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(0)); Assert.That(state.AllWatchedFolders.Count(), Is.EqualTo(1)); await state.AddWatchedFolderAsync(new WatchedFolder(knownFolder.My.FullName, IdentityPublicTag.Empty)); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1)); Assert.That(state.AllWatchedFolders.Count(), Is.EqualTo(1)); await state.RemoveAndDecryptWatchedFolder(knownFolder.My); Assert.That(state.WatchedFolders.Count(), Is.EqualTo(0)); Assert.That(state.AllWatchedFolders.Count(), Is.EqualTo(1)); } }
public async Task TestAlreadyKnownFoldersAndLoggingOn() { IDataContainer betterCloudInfo = New <IDataContainer>(@"C:\BetterCloud"); IDataContainer fasterCloudInfo = New <IDataContainer>(@"C:\FasterCloud"); KnownFolder folder1 = new KnownFolder(betterCloudInfo, @"My AxCrypt", KnownFolderKind.OneDrive, null); KnownFolder folder2 = new KnownFolder(fasterCloudInfo, @"My AxCrypt", KnownFolderKind.WindowsMyDocuments, null); FakeDataStore.AddFolder(folder1.My.FullName); FakeDataStore.AddFolder(folder2.My.FullName); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(folder1.My.FullName, new LogOnIdentity("PassPhrase").Tag)); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(folder2.My.FullName, new LogOnIdentity(new Passphrase("aaa")).Tag)); KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify); KnownFoldersViewModel vm = new KnownFoldersViewModel(Resolve.FileSystemState, Resolve.SessionNotify, knownIdentities); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(0)); vm.KnownFolders = new KnownFolder[] { folder1, folder2 }; Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.False); Assert.That(vm.KnownFolders.Last().Enabled, Is.False); await knownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity("aaa")); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.False, "This folder should not be enabled, because it's not watched by the signed in identity."); Assert.That(vm.KnownFolders.Last().Enabled, Is.True, "This folder should be enabled, since it is watched by the signed in identity."); }
public async Task TestHandleSessionEvents(CryptoImplementation cryptoImplementation) { SetupAssembly.AssemblySetupCrypto(cryptoImplementation); MockAxCryptFile mock = new MockAxCryptFile(); int callTimes = 0; mock.EncryptFilesUniqueWithBackupAndWipeMockAsync = async(IEnumerable <IDataContainer> folderInfos, EncryptionParameters encryptionParameters, IProgressContext progress) => { await Task.Delay(0); if (folderInfos.First().FullName == @"C:\My Documents\".NormalizeFilePath()) { ++callTimes; } }; Mock <IStatusChecker> mockStatusChecker = new Mock <IStatusChecker>(); SessionNotificationHandler handler = new SessionNotificationHandler(Resolve.FileSystemState, Resolve.KnownIdentities, New <ActiveFileAction>(), mock, mockStatusChecker.Object); FakeDataStore.AddFolder(@"C:\My Documents"); LogOnIdentity key = new LogOnIdentity("passphrase"); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\My Documents", key.Tag)); List <SessionNotification> sessionEvents = new List <SessionNotification>(); sessionEvents.Add(new SessionNotification(SessionNotificationType.WatchedFolderAdded, new LogOnIdentity("passphrase1"), @"C:\My Documents\")); sessionEvents.Add(new SessionNotification(SessionNotificationType.WatchedFolderAdded, new LogOnIdentity("passphrase"), @"C:\My Documents\")); foreach (SessionNotification sessionEvent in sessionEvents) { await handler.HandleNotificationAsync(sessionEvent); } Assert.That(callTimes, Is.EqualTo(2)); }
public async Task TestHandleSessionEventLogOffWithWatchedFolders(CryptoImplementation cryptoImplementation) { SetupAssembly.AssemblySetupCrypto(cryptoImplementation); MockAxCryptFile mock = new MockAxCryptFile(); bool called = false; mock.EncryptFilesUniqueWithBackupAndWipeMockAsync = async(IEnumerable <IDataContainer> folderInfos, EncryptionParameters encryptionParameters, IProgressContext progress) => { await Task.Delay(0); called = true; }; Mock <IStatusChecker> mockStatusChecker = new Mock <IStatusChecker>(); await Resolve.KnownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity("passphrase")); SessionNotificationHandler handler = new SessionNotificationHandler(Resolve.FileSystemState, Resolve.KnownIdentities, New <ActiveFileAction>(), mock, mockStatusChecker.Object); FakeDataStore.AddFolder(@"C:\WatchedFolder"); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder", Resolve.KnownIdentities.DefaultEncryptionIdentity.Tag)); called = false; await handler.HandleNotificationAsync(new SessionNotification(SessionNotificationType.EncryptPendingFiles)); await handler.HandleNotificationAsync(new SessionNotification(SessionNotificationType.SignOut, Resolve.KnownIdentities.DefaultEncryptionIdentity)); Assert.That(called, Is.True, nameof(AxCryptFile.EncryptFoldersUniqueWithBackupAndWipeAsync) + " should be called when a signing out."); }
public async Task TestCheckProcessExitedWhenExited() { DateTime utcNow = New <INow>().Utc; FakeDataStore.AddFile(_anAxxPath, utcNow, utcNow, utcNow, new MemoryStream(Resources.helloworld_key_a_txt)); FakeDataStore.AddFile(_decryptedFile1, utcNow, utcNow, utcNow, Stream.Null); await New <KnownIdentities>().SetDefaultEncryptionIdentity(new LogOnIdentity(EmailAddress.Parse("*****@*****.**"), new Passphrase("test"))); FakeLauncher fakeLauncher = new FakeLauncher(); fakeLauncher.Launch(_decryptedFile1); ActiveFile activeFile = new ActiveFile(New <IDataStore>(_anAxxPath), New <IDataStore>(_decryptedFile1), new LogOnIdentity("passphrase"), ActiveFileStatus.NotDecrypted, new V1Aes128CryptoFactory().CryptoId); activeFile = new ActiveFile(activeFile, ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.NotShareable); Resolve.FileSystemState.Add(activeFile, fakeLauncher); ((FakeNow)New <INow>()).TimeFunction = (() => { return(utcNow.AddMinutes(1)); }); bool changedWasRaised = false; Resolve.SessionNotify.AddCommand((SessionNotification notification) => { changedWasRaised = notification.NotificationType == SessionNotificationType.ActiveFileChange; return(Constant.CompletedTask); }); SetupAssembly.FakeRuntimeEnvironment.Platform = Platform.WindowsDesktop; fakeLauncher.HasExited = true; await New <ActiveFileAction>().CheckActiveFiles(new ProgressContext()); activeFile = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(_anAxxPath); Assert.That(changedWasRaised, Is.True, "A changed event should be raised because the process has exited."); Assert.That(activeFile.Status.HasMask(ActiveFileStatus.NotDecrypted), Is.True, "The ActiveFile plain text should be deleted after the checking of active files because the launcher is no longer active."); Assert.That(activeFile.Status.HasMask(ActiveFileStatus.NotShareable), Is.False, "The file should be shareable after checking of active files because the launcher is no longer active."); }
public async Task TestPurgeActiveFilesWhenFileIsLocked() { DateTime utcNow = New <INow>().Utc; FakeDataStore.AddFile(_anAxxPath, utcNow, utcNow, utcNow, new MemoryStream(Resources.helloworld_key_a_txt)); FakeDataStore.AddFile(_decryptedFile1, utcNow, utcNow, utcNow, Stream.Null); IDataStore encryptedFileInfo = New <IDataStore>(_anAxxPath); IDataStore decryptedFileInfo = New <IDataStore>(_decryptedFile1); ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); Resolve.FileSystemState.Add(activeFile); bool changedWasRaised = false; Resolve.SessionNotify.AddCommand((SessionNotification notification) => { changedWasRaised = notification.NotificationType == SessionNotificationType.ActiveFileChange; return(Constant.CompletedTask); }); using (FileLock fileLock = New <FileLocker>().Acquire(decryptedFileInfo)) { await Task.Run(() => New <ActiveFileAction>().PurgeActiveFiles(new ProgressContext())); } Assert.That(changedWasRaised, Is.False, "A changed event should not be raised because the decrypted file is locked."); }
public async Task TestCheckActiveFilesNotDecryptedAndDoesNotExist() { DateTime utcNow = New <INow>().Utc; FakeDataStore.AddFile(_anAxxPath, utcNow, utcNow, utcNow, new MemoryStream(Resources.helloworld_key_a_txt)); FakeDataStore.AddFile(_decryptedFile1, utcNow, utcNow, utcNow, Stream.Null); ActiveFile activeFile = new ActiveFile(New <IDataStore>(_anAxxPath), New <IDataStore>(_decryptedFile1), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); New <IDataStore>(_decryptedFile1).Delete(); activeFile = new ActiveFile(activeFile, ActiveFileStatus.NotDecrypted); Resolve.FileSystemState.Add(activeFile); await Resolve.KnownIdentities.AddAsync(activeFile.Identity); bool changedWasRaised = false; Resolve.SessionNotify.AddCommand((SessionNotification notification) => { changedWasRaised = notification.NotificationType == SessionNotificationType.ActiveFileChange; return(Constant.CompletedTask); }); ((FakeNow)New <INow>()).TimeFunction = (() => { return(utcNow.AddMinutes(1)); }); await New <ActiveFileAction>().CheckActiveFiles(new ProgressContext()); Assert.That(changedWasRaised, Is.False, "The ActiveFile should be not be modified because it's already deleted."); }
public async Task TestNotificationEncryptPendingFilesInLoggedOnFolders(CryptoImplementation cryptoImplementation) { SetupAssembly.AssemblySetupCrypto(cryptoImplementation); FakeDataStore.AddFolder(@"C:\My Documents\"); Mock <AxCryptFile> mock = new Mock <AxCryptFile>(); mock.Setup(acf => acf.EncryptFoldersUniqueWithBackupAndWipeAsync(It.IsAny <IEnumerable <IDataContainer> >(), It.IsAny <EncryptionParameters>(), It.IsAny <IProgressContext>())); Mock <IStatusChecker> mockStatusChecker = new Mock <IStatusChecker>(); SessionNotificationHandler handler = new SessionNotificationHandler(Resolve.FileSystemState, Resolve.KnownIdentities, New <ActiveFileAction>(), mock.Object, mockStatusChecker.Object); LogOnIdentity defaultKey = new LogOnIdentity("default"); await Resolve.KnownIdentities.SetDefaultEncryptionIdentity(defaultKey); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\My Documents\", defaultKey.Tag)); List <SessionNotification> sessionEvents = new List <SessionNotification>(); sessionEvents.Add(new SessionNotification(SessionNotificationType.EncryptPendingFiles)); foreach (SessionNotification sessionEvent in sessionEvents) { await handler.HandleNotificationAsync(sessionEvent); } mock.Verify(acf => acf.EncryptFoldersUniqueWithBackupAndWipeAsync(It.Is <IEnumerable <IDataContainer> >(infos => infos.Any((i) => i.FullName == @"C:\My Documents\".NormalizeFolderPath())), It.IsAny <EncryptionParameters>(), It.IsAny <IProgressContext>()), Times.Exactly(1)); }
public async Task TestSettingKnownFoldersAndLoggingOnAndOff() { KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify); KnownFoldersViewModel vm = new KnownFoldersViewModel(Resolve.FileSystemState, Resolve.SessionNotify, knownIdentities); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(0)); IDataContainer betterCloudInfo = New <IDataContainer>(@"C:\BetterCloud"); IDataContainer fasterCloudInfo = New <IDataContainer>(@"C:\FasterCloud"); KnownFolder folder1 = new KnownFolder(betterCloudInfo, @"My AxCrypt", KnownFolderKind.WindowsMyDocuments, null); KnownFolder folder2 = new KnownFolder(fasterCloudInfo, @"My AxCrypt", KnownFolderKind.Dropbox, null); FakeDataStore.AddFolder(folder1.My.FullName); FakeDataStore.AddFolder(folder2.My.FullName); vm.KnownFolders = new KnownFolder[] { folder1, folder2 }; Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.False, "We are not signed in so the folder should not be enabled"); Assert.That(vm.KnownFolders.Last().Enabled, Is.False, "We are not signed in so the folder should not be enabled"); await knownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity("aaa")); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.True, "We are signed in so the folder should be enabled"); Assert.That(vm.KnownFolders.Last().Enabled, Is.True, "We are signed in so the folder should be enabled"); await knownIdentities.SetDefaultEncryptionIdentity(LogOnIdentity.Empty); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.False, "We are no longer signed in so the folder should not be enabled"); Assert.That(vm.KnownFolders.Last().Enabled, Is.False, "We are no longer signed in so the folder should not be enabled"); }
internal static void TestOneFile(string resourceName, string password, string sha256HashValue) { string source = Path.Combine(_rootPath, "source.axx"); string destination = Path.Combine(_rootPath, "destination.file"); Stream stream = Assembly.GetAssembly(typeof(TestV2RegressionCompleteFiles)).GetManifestResourceStream("Axantum.AxCrypt.Core.Test.resources." + resourceName); FakeDataStore.AddFile(source, FakeDataStore.TestDate1Utc, FakeDataStore.TestDate2Utc, FakeDataStore.TestDate3Utc, stream); LogOnIdentity passphrase = new LogOnIdentity(password); bool ok = new AxCryptFile().Decrypt(New <IDataStore>(source), New <IDataStore>(destination), passphrase, AxCryptOptions.SetFileTimes, new ProgressContext()); Assert.That(ok, Is.True, "The Decrypt() method should return true for ok."); byte[] hash; HashAlgorithm hashAlgorithm = SHA256.Create(); Stream plainStream = New <IDataStore>(destination).OpenRead(); using (Stream cryptoStream = new CryptoStream(plainStream, hashAlgorithm, CryptoStreamMode.Read)) { plainStream = null; cryptoStream.CopyTo(Stream.Null); } hash = hashAlgorithm.Hash; Assert.That(hash.IsEquivalentTo(sha256HashValue.FromHex()), "Wrong SHA-256."); }
public async Task TestFileWasCreatedWhereAKnownFolderWasExpected() { IDataContainer betterCloudInfo = New <IDataContainer>(@"C:\BetterCloud"); IDataContainer fasterCloudInfo = New <IDataContainer>(@"C:\FasterCloud"); KnownFolder folder1 = new KnownFolder(betterCloudInfo, @"My AxCrypt", KnownFolderKind.GoogleDrive, null); KnownFolder folder2 = new KnownFolder(fasterCloudInfo, @"My AxCrypt", KnownFolderKind.Dropbox, null); FakeDataStore.AddFile(@"C:\BetterCloud\My AxCrypt", Stream.Null); FakeDataStore.AddFolder(folder2.My.FullName); KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify); KnownFoldersViewModel vm = new KnownFoldersViewModel(Resolve.FileSystemState, Resolve.SessionNotify, knownIdentities); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(0)); vm.KnownFolders = new KnownFolder[] { folder1, folder2 }; Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.False); Assert.That(vm.KnownFolders.Last().Enabled, Is.False); await knownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity("aaa")); Assert.That(Resolve.FileSystemState.WatchedFolders.Count(), Is.EqualTo(1)); Assert.That(vm.KnownFolders.Count(), Is.EqualTo(2)); Assert.That(vm.KnownFolders.First().Enabled, Is.False); Assert.That(vm.KnownFolders.Last().Enabled, Is.True); }
public void TestDragAndDropFilesPropertyBindSetsDragAndDropFileTypes() { using (MainViewModel mvm = New <MainViewModel>()) { string encryptedFilePath = @"C:\Folder\File-txt.axx"; mvm.DragAndDropFiles = new string[] { encryptedFilePath, }; Assert.That(mvm.DragAndDropFilesTypes, Is.EqualTo(FileInfoTypes.None)); string decryptedFilePath = @"C:\Folder\File.txt"; mvm.DragAndDropFiles = new string[] { decryptedFilePath, }; Assert.That(mvm.DragAndDropFilesTypes, Is.EqualTo(FileInfoTypes.None)); FakeDataStore.AddFile(encryptedFilePath, null); mvm.DragAndDropFiles = new string[] { encryptedFilePath, decryptedFilePath, }; Assert.That(mvm.DragAndDropFilesTypes, Is.EqualTo(FileInfoTypes.EncryptedFile)); FakeDataStore.AddFile(decryptedFilePath, null); mvm.DragAndDropFiles = new string[] { encryptedFilePath, decryptedFilePath, }; Assert.That(mvm.DragAndDropFilesTypes, Is.EqualTo(FileInfoTypes.EncryptableFile | FileInfoTypes.EncryptedFile)); string folderPath = @"C:\Folder\"; mvm.DragAndDropFiles = new string[] { encryptedFilePath, decryptedFilePath, folderPath }; Assert.That(mvm.DragAndDropFilesTypes, Is.EqualTo(FileInfoTypes.EncryptableFile | FileInfoTypes.EncryptedFile)); FakeDataStore.AddFolder(folderPath); mvm.DragAndDropFiles = new string[] { encryptedFilePath, decryptedFilePath, folderPath }; Assert.That(mvm.DragAndDropFilesTypes, Is.EqualTo(FileInfoTypes.EncryptableFile | FileInfoTypes.EncryptedFile)); } }
public void TestInvalidArguments() { using (Stream inputStream = FakeDataStore.ExpandableMemoryStream(Encoding.UTF8.GetBytes("AxCrypt is Great!"))) { using (Stream outputStream = new MemoryStream()) { using (V1AxCryptDocument document = new V1AxCryptDocument()) { Assert.Throws <ArgumentNullException>(() => { document.EncryptTo(inputStream, null, AxCryptOptions.EncryptWithCompression); }); Assert.Throws <ArgumentNullException>(() => { document.EncryptTo(null, outputStream, AxCryptOptions.EncryptWithCompression); }); Assert.Throws <ArgumentException>(() => { document.EncryptTo(inputStream, new NonSeekableStream(), AxCryptOptions.EncryptWithCompression); }); Assert.Throws <ArgumentException>(() => { document.EncryptTo(inputStream, outputStream, AxCryptOptions.EncryptWithCompression | AxCryptOptions.EncryptWithoutCompression); }); Assert.Throws <ArgumentException>(() => { document.EncryptTo(inputStream, outputStream, AxCryptOptions.None); }); Passphrase passphrase = new Passphrase("a"); V1DocumentHeaders headers = new V1DocumentHeaders(passphrase, 13); Assert.Throws <ArgumentNullException>(() => { document.CopyEncryptedTo(null, outputStream); }); Assert.Throws <ArgumentNullException>(() => { document.CopyEncryptedTo(headers, null); }); Assert.Throws <ArgumentException>(() => { document.CopyEncryptedTo(headers, new NonSeekableStream()); }); Assert.Throws <InternalErrorException>(() => { document.CopyEncryptedTo(headers, outputStream); }); } } } }
public static void Setup() { SetupAssembly.AssemblySetup(); FakeDataStore.AddFile(_davidCopperfieldTxtPath, FakeDataStore.TestDate4Utc, FakeDataStore.TestDate5Utc, FakeDataStore.TestDate6Utc, FakeDataStore.ExpandableMemoryStream(Encoding.GetEncoding(1252).GetBytes(Resources.david_copperfield))); FakeDataStore.AddFile(_uncompressedAxxPath, FakeDataStore.ExpandableMemoryStream(Resources.uncompressable_zip)); FakeDataStore.AddFile(_helloWorldAxxPath, FakeDataStore.ExpandableMemoryStream(Resources.helloworld_key_a_txt)); }
public static void Setup() { SetupAssembly.AssemblySetup(); TypeMap.Register.Singleton <ISettingsStore>(() => new SettingsStore(Resolve.WorkFolder.FileInfo.FileItemInfo("UserSettings.txt"))); TypeMap.Register.Singleton <UserSettingsVersion>(() => new UserSettingsVersion()); TypeMap.Register.Singleton <UserSettings>(() => new UserSettings(New <ISettingsStore>(), New <IterationCalculator>())); FakeDataStore.AddFolder(@"C:\Folder\"); }
public void Setup() { SetupAssembly.AssemblySetup(); SetupAssembly.AssemblySetupCrypto(_cryptoImplementation); FakeDataStore.AddFile(_testTextPath, FakeDataStore.TestDate1Utc, FakeDataStore.TestDate2Utc, FakeDataStore.TestDate3Utc, FakeDataStore.ExpandableMemoryStream(Encoding.UTF8.GetBytes("This is a short file"))); FakeDataStore.AddFile(_davidCopperfieldTxtPath, FakeDataStore.TestDate4Utc, FakeDataStore.TestDate5Utc, FakeDataStore.TestDate6Utc, FakeDataStore.ExpandableMemoryStream(Encoding.GetEncoding(1252).GetBytes(Resources.david_copperfield))); FakeDataStore.AddFile(_uncompressedAxxPath, FakeDataStore.ExpandableMemoryStream(Resources.uncompressable_zip)); FakeDataStore.AddFile(_helloWorldAxxPath, FakeDataStore.ExpandableMemoryStream(Resources.helloworld_key_a_txt)); }
public static void TestExtensions_FileFilter() { FakeDataStore.AddFile(@"c:\test.txt", null); IDataStore fileInfo = New <IDataStore>(@"c:\test.txt"); Assert.That(New <FileFilter>().IsEncryptable(fileInfo), Is.True); New <FileFilter>().AddUnencryptableExtension("txt"); Assert.That(New <FileFilter>().IsEncryptable(fileInfo), Is.False); }
public static void TestFindMagicGuidFromSimpleFile() { using (Stream testStream = FakeDataStore.ExpandableMemoryStream(Resources.helloworld_key_a_txt)) { using (V1AxCryptReader axCryptReader = new V1AxCryptReader(new LookAheadStream(testStream))) { Assert.That(axCryptReader.Read(), Is.True, "We should be able to read the Guid"); Assert.That(axCryptReader.CurrentItemType, Is.EqualTo(AxCryptItemType.MagicGuid), "We're expecting to have found a MagicGuid"); } } }
public void Setup() { SetupAssembly.AssemblySetup(); SetupAssembly.AssemblySetupCrypto(_cryptoImplementation); FakeDataStore.AddFile(_davidCopperfieldTxtPath, FakeDataStore.TestDate4Utc, FakeDataStore.TestDate5Utc, FakeDataStore.TestDate6Utc, FakeDataStore.ExpandableMemoryStream(Encoding.GetEncoding(1252).GetBytes(Resources.david_copperfield))); FakeDataStore.AddFile(_uncompressedAxxPath, FakeDataStore.ExpandableMemoryStream(Resources.uncompressable_zip)); FakeDataStore.AddFile(_helloWorldAxxPath, FakeDataStore.ExpandableMemoryStream(Resources.helloworld_key_a_txt)); TypeMap.Register.Singleton <IUIThread>(() => new FakeUIThread()); }
public async Task TestWatchedFoldersNotLoggedOn() { KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify); FakeDataStore.AddFolder(@"C:\WatchedFolder\"); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder\", IdentityPublicTag.Empty)); IEnumerable <WatchedFolder> watchedFolders = knownIdentities.LoggedOnWatchedFolders; Assert.That(watchedFolders.Count(), Is.EqualTo(0), "When not logged on, no watched folders should be known."); }
/// <summary> /// Khởi tạo các thực thể trống /// </summary> /// <returns></returns> public static FakeDataStore GetEmpty() { FakeDataStore datastore = new FakeDataStore(); datastore.Albums = new FakeDbSet<Album>(); datastore.Artists = new FakeDbSet<Artist>(); datastore.Carts = new FakeDbSet<Cart>(); datastore.Genres = new FakeDbSet<Genre>(); datastore.OrderDetails = new FakeDbSet<OrderDetail>(); datastore.Orders = new FakeDbSet<Order>(); return datastore; }
public void AddProductToCartInNegative() { FakeDataStore dataStore = MusicStoreEntitiesFactory.GetEmpty(); dataStore.GenerateAndAddGenre(1); dataStore.GenerateAndAddArtist(1); dataStore.GenerateAndAddAlbum(2, 1, 1, 10M); ShoppingCartController controller = ControllerFactory.GetWiredUpController((s) => new ShoppingCartController(s), store: dataStore); RedirectToRouteResult result = controller.AddToCart(2, -5) as RedirectToRouteResult; Assert.IsTrue(result.RouteValues.ContainsValue("InvalidRequest")); }
public void TestValidateWrongButKnownPassphraseWithRealFile() { _identities.Add(new Passphrase("b")); FakeDataStore.AddFile(@"C:\My Folder\MyFile-txt.axx", new MemoryStream(Resources.helloworld_key_a_txt)); FilePasswordViewModel npvm = new FilePasswordViewModel(@"C:\My Folder\MyFile-txt.axx"); npvm.PasswordText = "b"; Assert.That(npvm[nameof(FilePasswordViewModel.PasswordText)], Is.Not.EqualTo(String.Empty)); Assert.That(npvm.ValidationError, Is.EqualTo((int)ValidationError.WrongPassphrase)); }
public async Task TestSimpleCreateAsymmetricKeysStore() { FakeDataStore.AddFolder(@"C:\Temp"); IDataContainer workFolder = New <IDataContainer>(@"C:\Temp"); AccountStorage store = new AccountStorage(new LocalAccountService(new LogOnIdentity(EmailAddress.Parse(@"*****@*****.**"), new Passphrase("secret")), workFolder)); UserKeyPair userKeyPair = new UserKeyPair(EmailAddress.Parse("*****@*****.**"), 512); await store.ImportAsync(userKeyPair); Assert.That((await store.AllKeyPairsAsync()).First().KeyPair.PrivateKey, Is.Not.Null); Assert.That((await store.AllKeyPairsAsync()).First().KeyPair.PublicKey, Is.Not.Null); }
public async Task TestCheckActiveFilesUpdateButWithTargetInaccessible() { DateTime utcNow = New <INow>().Utc; FakeDataStore.AddFile(_anAxxPath, utcNow, utcNow, utcNow, FakeDataStore.ExpandableMemoryStream(Resources.helloworld_key_a_txt)); LogOnIdentity passphrase = new LogOnIdentity("a"); New <AxCryptFile>().Decrypt(New <IDataStore>(_anAxxPath), New <IDataStore>(_decryptedFile1), passphrase, AxCryptOptions.None, new ProgressContext()); ActiveFile activeFile = new ActiveFile(New <IDataStore>(_anAxxPath), New <IDataStore>(_decryptedFile1), passphrase, ActiveFileStatus.AssumedOpenAndDecrypted, new V1Aes128CryptoFactory().CryptoId); Resolve.FileSystemState.Add(activeFile); IDataStore decryptedFileInfo = New <IDataStore>(_decryptedFile1); decryptedFileInfo.SetFileTimes(utcNow.AddSeconds(30), utcNow.AddSeconds(30), utcNow.AddSeconds(30)); ((FakeNow)New <INow>()).TimeFunction = (() => { return(utcNow.AddMinutes(1)); }); await Resolve.KnownIdentities.AddAsync(passphrase); bool changedWasRaised = false; Resolve.SessionNotify.AddCommand((SessionNotification notification) => { changedWasRaised = notification.NotificationType == SessionNotificationType.ActiveFileChange && notification.FullNames.Contains(_anAxxPath); return(Constant.CompletedTask); }); EventHandler eventHandler = ((object sender, EventArgs e) => { FakeDataStore fileInfo = (FakeDataStore)sender; if (fileInfo.FullName == Path.ChangeExtension(_anAxxPath, ".tmp")) { throw new IOException("Faked access denied."); } }); FakeDataStore.OpeningForWrite += eventHandler; try { Assert.ThrowsAsync <FileOperationException>(async() => await New <ActiveFileAction>().CheckActiveFiles(new ProgressContext())); } finally { FakeDataStore.OpeningForWrite -= eventHandler; } Assert.That(changedWasRaised, Is.False, "The ActiveFile should not be modified because it was not accessible."); activeFile = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(_anAxxPath); Assert.That(activeFile.Status.HasMask(ActiveFileStatus.NotShareable), Is.False, "The ActiveFile should not be marked as not shareable after the checking of active files."); }
public static void TestValidateWrongPassphraseWithRealFile(CryptoImplementation cryptoImplementation) { SetupAssembly.AssemblySetupCrypto(cryptoImplementation); FakeDataStore.AddFile(@"C:\My Folder\MyFile-txt.axx", new MemoryStream(Resources.helloworld_key_a_txt)); NewPasswordViewModel npvm = new NewPasswordViewModel(String.Empty, @"C:\My Folder\MyFile-txt.axx"); npvm.PasswordText = "b"; npvm.Verification = "b"; Assert.That(npvm[nameof(NewPasswordViewModel.PasswordText)], Is.Not.EqualTo("")); Assert.That(npvm.ValidationError, Is.EqualTo((int)ValidationError.WrongPassphrase)); }
public async Task TestSetFilesArePending() { await Resolve.KnownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity("passphrase")); FakeDataStore.AddFolder(@"C:\MyFolders\Folder1"); using (MainViewModel mvm = New <MainViewModel>()) { Assert.That(mvm.FilesArePending, Is.False); await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\MyFolders\Folder1", Resolve.KnownIdentities.DefaultEncryptionIdentity.Tag)); FakeDataStore.AddFile(@"C:\MyFolders\Folder1\Encryptable.txt", Stream.Null); Assert.That(mvm.FilesArePending, Is.True); } }