Esempio n. 1
0
        /// <summary>
        /// Iterate over all active files in the state.
        /// </summary>
        /// <param name="mode">RaiseAlways to raise Changed event for each active file, RaiseOnlyOnModified to only raise for modified active files.</param>
        /// <param name="action">A delegate with an action to take for each active file, returning the same or updated active file as need be.</param>
        public void ForEach(ChangedEventMode mode, Func <ActiveFile, ActiveFile> action)
        {
            if (action == null)
            {
                throw new ArgumentNullException("action");
            }

            bool isModified = false;
            List <ActiveFile> activeFiles = new List <ActiveFile>();

            foreach (ActiveFile activeFile in ActiveFiles)
            {
                ActiveFile updatedActiveFile = action(activeFile);
                activeFiles.Add(updatedActiveFile);
                if (updatedActiveFile != activeFile)
                {
                    isModified = true;
                    OnChanged(new ActiveFileChangedEventArgs(updatedActiveFile));
                    activeFile.Dispose();
                }
            }
            if (isModified)
            {
                lock (_lock)
                {
                    SetRangeInternal(activeFiles, ActiveFileStatus.None);
                }
                Save();
            }
            if (!isModified && mode == ChangedEventMode.RaiseAlways)
            {
                RaiseChangedForAll(activeFiles);
            }
        }
Esempio n. 2
0
 /// <summary>
 /// Try do delete files that have been decrypted temporarily, if the conditions are met for such a deletion,
 /// i.e. it is apparently not locked or in use etc.
 /// </summary>
 /// <param name="fileSystemState">The instance of FileSystemState where active files are recorded.</param>
 /// <param name="progress">The context where progress may be reported.</param>
 public static void PurgeActiveFiles(this FileSystemState fileSystemState, ProgressContext progress)
 {
     progress.NotifyLevelStart();
     fileSystemState.ForEach(ChangedEventMode.RaiseOnlyOnModified, (ActiveFile activeFile) =>
     {
         if (FileLock.IsLocked(activeFile.DecryptedFileInfo))
         {
             if (OS.Log.IsInfoEnabled)
             {
                 OS.Log.LogInfo("Not deleting '{0}' because it is marked as locked.".InvariantFormat(activeFile.DecryptedFileInfo.FullName));
             }
             return(activeFile);
         }
         if (activeFile.IsModified)
         {
             if (activeFile.Status.HasMask(ActiveFileStatus.NotShareable))
             {
                 activeFile = new ActiveFile(activeFile, activeFile.Status & ~ActiveFileStatus.NotShareable);
             }
             activeFile = CheckIfTimeToUpdate(activeFile, progress);
         }
         if (activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted))
         {
             activeFile = TryDelete(activeFile, progress);
         }
         return(activeFile);
     });
     progress.NotifyLevelFinished();
 }
Esempio n. 3
0
        public virtual async Task <ActiveFile> CheckActiveFile(ActiveFile activeFile, IProgressContext progress)
        {
            if (activeFile == null)
            {
                throw new ArgumentNullException("activeFile");
            }

            try
            {
                if (activeFile.Status.HasMask(ActiveFileStatus.Exception))
                {
                    return(activeFile);
                }

                if (New <FileLocker>().IsLocked(activeFile.DecryptedFileInfo, activeFile.EncryptedFileInfo))
                {
                    return(activeFile);
                }
                using (FileLock decryptedFileLock = New <FileLocker>().Acquire(activeFile.DecryptedFileInfo))
                {
                    using (FileLock encryptedFileLock = New <FileLocker>().Acquire(activeFile.EncryptedFileInfo))
                    {
                        activeFile = await CheckActiveFileActions(activeFile, encryptedFileLock, decryptedFileLock, progress).Free();

                        return(activeFile);
                    }
                }
            }
            catch (Exception ex) when(!(ex is AxCryptException))
            {
                throw new FileOperationException("Unexpected exception checking active files.", $"{activeFile.EncryptedFileInfo.FullName} : {activeFile.DecryptedFileInfo.FullName}", ErrorStatus.Exception, ex);
            }
        }
Esempio n. 4
0
        public virtual async Task RemoveRecentFiles(IEnumerable <IDataStore> encryptedPaths, IProgressContext progress)
        {
            if (encryptedPaths == null)
            {
                throw new ArgumentNullException("encryptedPaths");
            }
            if (progress == null)
            {
                throw new ArgumentNullException("progress");
            }

            progress.NotifyLevelStart();
            try
            {
                progress.AddTotal(encryptedPaths.Count());
                foreach (IDataStore encryptedPath in encryptedPaths)
                {
                    ActiveFile activeFile = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(encryptedPath.FullName);
                    if (activeFile != null)
                    {
                        Resolve.FileSystemState.RemoveActiveFile(activeFile);
                    }
                    progress.AddCount(1);
                }
                await Resolve.FileSystemState.Save().Free();
            }
            finally
            {
                progress.NotifyLevelFinished();
            }
        }
Esempio n. 5
0
        private static async Task <ActiveFile> CheckIfTimeToDelete(ActiveFile activeFile, FileLock decryptedFileLock, IProgressContext progress)
        {
            switch (OS.Current.Platform)
            {
            case Platform.WindowsDesktop:
            case Platform.Linux:
            case Platform.MacOsx:
                break;

            default:
                return(activeFile);
            }

            if (!activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted))
            {
                return(activeFile);
            }
            if (activeFile.Status.HasMask(ActiveFileStatus.NotShareable))
            {
                return(activeFile);
            }
            if (activeFile.Status.HasMask(ActiveFileStatus.NoProcessKnown))
            {
                return(activeFile);
            }
            if (Resolve.ProcessState.HasActiveProcess(activeFile))
            {
                return(activeFile);
            }

            activeFile = await TryDelete(activeFile, decryptedFileLock, progress).Free();

            return(activeFile);
        }
Esempio n. 6
0
 /// <summary>
 /// Add a file to the volatile file system state. To persist, call Save().
 /// </summary>
 /// <param name="activeFile">The active file to save</param>
 public void Add(ActiveFile activeFile)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     AddInternal(activeFile);
 }
Esempio n. 7
0
 private void AddInternal(ActiveFile activeFile)
 {
     lock (_activeFilesByEncryptedPath)
     {
         _activeFilesByEncryptedPath[activeFile.EncryptedFileInfo.FullName] = activeFile;
     }
     New <ActiveFileWatcher>().Add(activeFile.EncryptedFileInfo);
 }
Esempio n. 8
0
 private void Initialize(ActiveFile other)
 {
     Initialize(other.EncryptedFileInfo, other.DecryptedFileInfo, other.LastEncryptionWriteTimeUtc, other.Key, other.Thumbprint, other.Status, other.Process);
     if (other.Process != null)
     {
         other.Process = null;
     }
 }
Esempio n. 9
0
 public ActiveFile(ActiveFile activeFile, ActiveFileStatus status)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     Status = status;
 }
Esempio n. 10
0
 public ActiveFile(ActiveFile activeFile)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     Properties = new ActiveFileProperties(activeFile.Properties.LastActivityTimeUtc, Properties.LastEncryptionWriteTimeUtc, activeFile.Properties.CryptoId);
     Identity   = LogOnIdentity.Empty;
 }
Esempio n. 11
0
        public ActiveFile(ActiveFile activeFile, Guid cryptoId, LogOnIdentity identity)
        {
            if (activeFile == null)
            {
                throw new ArgumentNullException("activeFile");
            }

            Initialize(activeFile, identity);
            Properties = new ActiveFileProperties(activeFile.Properties.LastActivityTimeUtc, activeFile.Properties.LastEncryptionWriteTimeUtc, cryptoId);
        }
Esempio n. 12
0
 public ActiveFile(ActiveFile activeFile, ActiveFileStatus status, ILauncher process)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     Status  = status;
     Process = process;
 }
Esempio n. 13
0
 public ActiveFile(ActiveFile activeFile, DateTime lastEncryptionWriteTimeUtc, ActiveFileStatus status)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     Properties = new ActiveFileProperties(activeFile.Properties.LastActivityTimeUtc, lastEncryptionWriteTimeUtc, activeFile.Properties.CryptoId);
     Status     = status;
 }
Esempio n. 14
0
 public ActiveFile(ActiveFile activeFile, ActiveFileStatus status, ILauncher process)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     Status = status;
     Process = process;
 }
Esempio n. 15
0
 public ActiveFile(ActiveFile activeFile, DateTime lastEncryptionWriteTimeUtc, ActiveFileStatus status)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     LastEncryptionWriteTimeUtc = lastEncryptionWriteTimeUtc;
     Status = status;
 }
Esempio n. 16
0
        private async Task RemoveDeletedActiveFile(IDataItem dataItem)
        {
            ActiveFile removedActiveFile = FindActiveFileFromEncryptedPath(dataItem.FullName);

            if (removedActiveFile != null)
            {
                RemoveActiveFile(removedActiveFile);
                await Save();
            }
        }
Esempio n. 17
0
 public virtual async Task ClearExceptionState()
 {
     await Resolve.FileSystemState.ForEach(async (ActiveFile activeFile) =>
     {
         if (activeFile.Status.HasFlag(ActiveFileStatus.Exception))
         {
             activeFile = new ActiveFile(activeFile, activeFile.Status & ~ActiveFileStatus.Exception);
         }
         return(activeFile);
     }).Free();
 }
Esempio n. 18
0
        private static async Task <ActiveFile> CheckActiveFileActions(ActiveFile activeFile, FileLock encryptedFileLock, FileLock decryptedFileLock, IProgressContext progress)
        {
            activeFile = CheckIfKeyIsKnown(activeFile);
            activeFile = CheckIfCreated(activeFile);
            activeFile = CheckIfProcessExited(activeFile);
            activeFile = await CheckIfTimeToUpdate(activeFile, encryptedFileLock, decryptedFileLock, progress).Free();

            activeFile = await CheckIfTimeToDelete(activeFile, decryptedFileLock, progress).Free();

            return(activeFile);
        }
Esempio n. 19
0
 private static LogOnIdentity FindKnownKeyOrEmpty(ActiveFile activeFile)
 {
     foreach (LogOnIdentity key in Resolve.KnownIdentities.Identities)
     {
         if (activeFile.ThumbprintMatch(key.Passphrase))
         {
             return(key);
         }
     }
     return(LogOnIdentity.Empty);
 }
Esempio n. 20
0
 private List <ILauncher> ActiveProcesses(ActiveFile activeFile)
 {
     lock (_lock)
     {
         List <ILauncher> processes;
         if (!_processState.TryGetValue(activeFile.EncryptedFileInfo.FullName, out processes))
         {
             return(null);
         }
         return(processes);
     }
 }
Esempio n. 21
0
 /// <summary>
 /// Add a file to the volatile file system state. To persist, call Save().
 /// </summary>
 /// <param name="activeFile">The active file to save</param>
 public void Add(ActiveFile activeFile)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     lock (_lock)
     {
         AddInternal(activeFile);
     }
     OnChanged(new ActiveFileChangedEventArgs(activeFile));
 }
Esempio n. 22
0
 private static ActiveFile CheckIfProcessExited(ActiveFile activeFile)
 {
     if (activeFile.Process == null || !activeFile.Process.HasExited)
     {
         return(activeFile);
     }
     if (OS.Log.IsInfoEnabled)
     {
         OS.Log.LogInfo("Process exit for '{0}'".InvariantFormat(activeFile.DecryptedFileInfo.FullName));
     }
     activeFile = new ActiveFile(activeFile, activeFile.Status & ~ActiveFileStatus.NotShareable, null);
     return(activeFile);
 }
Esempio n. 23
0
            public override int Compare(ActiveFile x, ActiveFile y)
            {
                if (x == null)
                {
                    throw new ArgumentNullException("x");
                }
                if (y == null)
                {
                    throw new ArgumentNullException("y");
                }

                return((ReverseSort ? -1 : 1) * String.Compare(x.EncryptedFileInfo.FullName, y.EncryptedFileInfo.FullName, StringComparison.OrdinalIgnoreCase));
            }
Esempio n. 24
0
            public override int Compare(ActiveFile x, ActiveFile y)
            {
                if (x == null)
                {
                    throw new ArgumentNullException("x");
                }
                if (y == null)
                {
                    throw new ArgumentNullException("y");
                }

                return((ReverseSort ? -1 : 1) * String.Compare(Resolve.CryptoFactory.Create(x.Properties.CryptoId).Name, Resolve.CryptoFactory.Create(y.Properties.CryptoId).Name, StringComparison.OrdinalIgnoreCase));
            }
Esempio n. 25
0
            public override int Compare(ActiveFile x, ActiveFile y)
            {
                if (x == null)
                {
                    throw new ArgumentNullException("x");
                }
                if (y == null)
                {
                    throw new ArgumentNullException("y");
                }

                return((ReverseSort ? -1 : 1) * String.Compare(Resolve.Portable.Path().GetFileName(x.DecryptedFileInfo.FullName), Resolve.Portable.Path().GetFileName(y.DecryptedFileInfo.FullName), StringComparison.OrdinalIgnoreCase));
            }
Esempio n. 26
0
            public override int Compare(ActiveFile x, ActiveFile y)
            {
                if (x == null)
                {
                    throw new ArgumentNullException("x");
                }
                if (y == null)
                {
                    throw new ArgumentNullException("y");
                }

                return((ReverseSort ? -1 : 1) * x.Properties.LastActivityTimeUtc.CompareTo(y.Properties.LastActivityTimeUtc));
            }
Esempio n. 27
0
        private static async Task <ActiveFile> CheckIfTimeToUpdate(ActiveFile activeFile, FileLock encryptedFileLock, FileLock decryptedFileLock, IProgressContext progress)
        {
            if (!activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted) || activeFile.Status.HasMask(ActiveFileStatus.NotShareable))
            {
                return(activeFile);
            }
            if (New <KnownIdentities>().DefaultEncryptionIdentity == LogOnIdentity.Empty && activeFile.Identity == LogOnIdentity.Empty)
            {
                return(activeFile);
            }

            return(await activeFile.CheckUpdateDecrypted(encryptedFileLock, decryptedFileLock, progress).Free());
        }
Esempio n. 28
0
        private static ActiveFile CheckIfTimeToDelete(ActiveFile activeFile, ProgressContext progress)
        {
            if (OS.Current.Platform != Platform.WindowsDesktop)
            {
                return(activeFile);
            }
            if (!activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted) || activeFile.Status.HasMask(ActiveFileStatus.NotShareable))
            {
                return(activeFile);
            }

            activeFile = TryDelete(activeFile, progress);
            return(activeFile);
        }
Esempio n. 29
0
 /// <summary>
 /// Remove a file from the volatile file system state. To persist, call Save().
 /// </summary>
 /// <param name="activeFile">An active file to remove</param>
 public void Remove(ActiveFile activeFile)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     lock (_lock)
     {
         _activeFilesByDecryptedPath.Remove(activeFile.DecryptedFileInfo.FullName);
         _activeFilesByEncryptedPath.Remove(activeFile.EncryptedFileInfo.FullName);
     }
     activeFile = new ActiveFile(activeFile, activeFile.Status | ActiveFileStatus.NoLongerActive);
     OnChanged(new ActiveFileChangedEventArgs(activeFile));
 }
Esempio n. 30
0
 private void SetRangeInternal(IEnumerable <ActiveFile> activeFiles, ActiveFileStatus mask)
 {
     _activeFilesByDecryptedPath = new Dictionary <string, ActiveFile>();
     _activeFilesByEncryptedPath = new Dictionary <string, ActiveFile>();
     foreach (ActiveFile activeFile in activeFiles)
     {
         ActiveFile thisActiveFile = activeFile;
         if ((activeFile.Status & mask) != 0)
         {
             thisActiveFile = new ActiveFile(activeFile, activeFile.Status & ~mask, null);
         }
         AddInternal(thisActiveFile);
     }
 }
Esempio n. 31
0
 public ActiveFile(ActiveFile activeFile, AesKey key)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     Initialize(activeFile);
     LastActivityTimeUtc = activeFile.LastActivityTimeUtc;
     Key = key;
 }
Esempio n. 32
0
 public ActiveFile(ActiveFile activeFile, AesKey key)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     Initialize(activeFile);
     LastActivityTimeUtc = activeFile.LastActivityTimeUtc;
     Key = key;
 }
        public static void TestActiveFileCollectionEnumerationConstructor()
        {
            IRuntimeFileInfo decryptedFileInfo1 = OS.Current.FileInfo(Path.Combine(_rootPath, "test1.txt"));
            IRuntimeFileInfo encryptedFileInfo1 = OS.Current.FileInfo(Path.Combine(_rootPath, "test1-txt.axx"));
            IRuntimeFileInfo decryptedFileInfo2 = OS.Current.FileInfo(Path.Combine(_rootPath, "test2.txt"));
            IRuntimeFileInfo encryptedFileInfo2 = OS.Current.FileInfo(Path.Combine(_rootPath, "test2-text.axx"));
            ActiveFile activeFile1 = new ActiveFile(encryptedFileInfo1, decryptedFileInfo1, new AesKey(), ActiveFileStatus.None, null);
            ActiveFile activeFile2 = new ActiveFile(encryptedFileInfo2, decryptedFileInfo2, new AesKey(), ActiveFileStatus.None, null);

            ActiveFileCollection collection = new ActiveFileCollection(new ActiveFile[] { activeFile1, activeFile2 });

            Assert.That(collection.Count, Is.EqualTo(2), "There should be two entries in the collection.");

            Assert.That(collection.First(), Is.EqualTo(activeFile1), "This should be the first in the collection.");
            Assert.That(collection.Last(), Is.EqualTo(activeFile2), "This should be the last in the collection.");
        }
Esempio n. 34
0
        public static void TestConstructor()
        {
            AesKey key = new AesKey();
            ILauncher process = new FakeLauncher(String.Empty);
            IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_testTextPath);
            IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
            using (ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, process))
            {
                decryptedFileInfo = activeFile.DecryptedFileInfo;
                Assert.That(decryptedFileInfo.Exists, Is.True, "The file should exist in the fake file system.");
                Assert.That(decryptedFileInfo.FullName, Is.EqualTo(_testTextPath), "The file should be named as it was in the constructor");
                Assert.That(decryptedFileInfo.LastWriteTimeUtc, Is.EqualTo(decryptedFileInfo.LastWriteTimeUtc), "When a LastWriteTime is not specified, the decrypted file should be used to determine the value.");
                Assert.That(activeFile.Process, Is.EqualTo(process), "The process should be set from the constructor.");
                SetupAssembly.FakeRuntimeEnvironment.TimeFunction = (() => { return DateTime.UtcNow.AddMinutes(1); });
                using (ActiveFile otherFile = new ActiveFile(activeFile, ActiveFileStatus.AssumedOpenAndDecrypted))
                {
                    Assert.That(otherFile.Status, Is.EqualTo(ActiveFileStatus.AssumedOpenAndDecrypted), "The status should be as given in the constructor.");
                    Assert.That(otherFile.DecryptedFileInfo.FullName, Is.EqualTo(activeFile.DecryptedFileInfo.FullName), "This should be copied from the original instance.");
                    Assert.That(otherFile.EncryptedFileInfo.FullName, Is.EqualTo(activeFile.EncryptedFileInfo.FullName), "This should be copied from the original instance.");
                    Assert.That(otherFile.Key, Is.EqualTo(activeFile.Key), "This should be copied from the original instance.");
                    Assert.That(otherFile.LastActivityTimeUtc, Is.GreaterThan(activeFile.LastActivityTimeUtc), "This should not be copied from the original instance, but should be a later time.");
                    Assert.That(otherFile.Process, Is.EqualTo(process), "This should be copied from the original instance.");
                    Assert.That(activeFile.Process, Is.Null, "The process should only be owned by one instance at a time.");
                    Assert.That(otherFile.ThumbprintMatch(activeFile.Key), Is.True, "The thumbprints should match.");
                }

                using (ActiveFile otherFile = new ActiveFile(activeFile, ActiveFileStatus.AssumedOpenAndDecrypted, process))
                {
                    Assert.That(otherFile.Process, Is.EqualTo(process), "This should be copied from the instance provided in the constructor.");
                }

                activeFile.DecryptedFileInfo.LastWriteTimeUtc = activeFile.DecryptedFileInfo.LastWriteTimeUtc.AddDays(1);
                using (ActiveFile otherFile = new ActiveFile(activeFile, OS.Current.UtcNow, ActiveFileStatus.AssumedOpenAndDecrypted))
                {
                    Assert.That(activeFile.IsModified, Is.True, "The original instance has not been encrypted since the last change.");
                    Assert.That(otherFile.IsModified, Is.False, "The copy indicates that it has been encrypted and thus is not modified.");
                }
            }
        }
Esempio n. 35
0
 /// <summary>
 /// Remove a file from the volatile file system state. To persist, call Save().
 /// </summary>
 /// <param name="activeFile">An active file to remove</param>
 public void Remove(ActiveFile activeFile)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     lock (_lock)
     {
         _activeFilesByDecryptedPath.Remove(activeFile.DecryptedFileInfo.FullName);
         _activeFilesByEncryptedPath.Remove(activeFile.EncryptedFileInfo.FullName);
     }
     activeFile = new ActiveFile(activeFile, activeFile.Status | ActiveFileStatus.NoLongerActive);
     OnChanged(new ActiveFileChangedEventArgs(activeFile));
 }
Esempio n. 36
0
        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.");
            }
        }
Esempio n. 37
0
 private void AddInternal(ActiveFile activeFile)
 {
     _activeFilesByEncryptedPath[activeFile.EncryptedFileInfo.FullName] = activeFile;
     _activeFilesByDecryptedPath[activeFile.DecryptedFileInfo.FullName] = activeFile;
 }
Esempio n. 38
0
        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.");
            }
        }
Esempio n. 39
0
        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.");
            }
        }
Esempio n. 40
0
 public ActiveFile(ActiveFile activeFile, ActiveFileStatus status)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     Status = status;
 }
Esempio n. 41
0
        public static void TestThumbprintNullKey()
        {
            IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_testTextPath);
            IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
            ILauncher process = new FakeLauncher(String.Empty);

            AesKey key = new AesKey();
            using (MemoryStream stream = new MemoryStream())
            {
                using (ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, process))
                {
                    Assert.Throws<ArgumentNullException>(() =>
                    {
                        AesKey nullKey = null;
                        activeFile.ThumbprintMatch(nullKey);
                    });
                }
            }
        }
Esempio n. 42
0
        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.");
            }
        }
Esempio n. 43
0
        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.");
            }
        }
Esempio n. 44
0
 private static ActiveFile CheckKeysForAlreadyDecryptedFile(ActiveFile destinationActiveFile, IEnumerable<AesKey> keys, ProgressContext progress)
 {
     foreach (AesKey key in keys)
     {
         using (AxCryptDocument document = AxCryptFile.Document(destinationActiveFile.EncryptedFileInfo, key, progress))
         {
             if (document.PassphraseIsValid)
             {
                 if (OS.Log.IsWarningEnabled)
                 {
                     OS.Log.LogWarning("File was already decrypted and the key was known for '{0}' to '{1}'".InvariantFormat(destinationActiveFile.EncryptedFileInfo.FullName, destinationActiveFile.DecryptedFileInfo.FullName));
                 }
                 return new ActiveFile(destinationActiveFile, key);
             }
         }
     }
     return null;
 }
Esempio n. 45
0
 private void Initialize(ActiveFile other)
 {
     Initialize(other.EncryptedFileInfo, other.DecryptedFileInfo, other.LastEncryptionWriteTimeUtc, other.Key, other.Thumbprint, other.Status, other.Process);
     if (other.Process != null)
     {
         other.Process = null;
     }
 }
Esempio n. 46
0
 private void SetRangeInternal(IEnumerable<ActiveFile> activeFiles, ActiveFileStatus mask)
 {
     _activeFilesByDecryptedPath = new Dictionary<string, ActiveFile>();
     _activeFilesByEncryptedPath = new Dictionary<string, ActiveFile>();
     foreach (ActiveFile activeFile in activeFiles)
     {
         ActiveFile thisActiveFile = activeFile;
         if ((activeFile.Status & mask) != 0)
         {
             thisActiveFile = new ActiveFile(activeFile, activeFile.Status & ~mask, null);
         }
         AddInternal(thisActiveFile);
     }
 }
Esempio n. 47
0
 public static void TestCopyConstructorWithKey()
 {
     ILauncher process = new FakeLauncher(String.Empty);
     AesKey key = new AesKey();
     IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_testTextPath);
     IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
     using (ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, process))
     {
         AesKey newKey = new AesKey();
         using (ActiveFile newActiveFile = new ActiveFile(activeFile, newKey))
         {
             Assert.That(activeFile.Key, Is.Not.EqualTo(newKey), "Ensure that it's really a different key.");
             Assert.That(newActiveFile.Key, Is.EqualTo(newKey), "The constructor should assign the new key to the new ActiveFile instance.");
         }
     }
 }
Esempio n. 48
0
        private static ActiveFile DecryptActiveFileDocument(IRuntimeFileInfo sourceFileInfo, IRuntimeFileInfo destinationFolderInfo, AxCryptDocument document, ProgressContext progress)
        {
            string destinationName = document.DocumentHeaders.FileName;
            string destinationPath = Path.Combine(destinationFolderInfo.FullName, destinationName);

            IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(destinationPath);
            using (FileLock fileLock = FileLock.Lock(destinationFileInfo))
            {
                AxCryptFile.Decrypt(document, destinationFileInfo, AxCryptOptions.SetFileTimes, progress);
            }
            ActiveFile destinationActiveFile = new ActiveFile(sourceFileInfo, destinationFileInfo, document.DocumentHeaders.KeyEncryptingKey, ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.IgnoreChange, null);
            if (OS.Log.IsInfoEnabled)
            {
                OS.Log.LogInfo("File decrypted from '{0}' to '{1}'".InvariantFormat(sourceFileInfo.FullName, destinationActiveFile.DecryptedFileInfo.FullName));
            }
            return destinationActiveFile;
        }
Esempio n. 49
0
 public static void TestMethodIsModified()
 {
     IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(Path.Combine(_rootPath, "doesnotexist.txt"));
     IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
     using (ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, new AesKey(), ActiveFileStatus.None, null))
     {
         Assert.That(activeFile.IsModified, Is.False, "A non-existing decrypted file should not be treated as modified.");
     }
 }
Esempio n. 50
0
        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.");
            }
        }
Esempio n. 51
0
 public ActiveFile(ActiveFile activeFile, DateTime lastEncryptionWriteTimeUtc, ActiveFileStatus status)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     Initialize(activeFile);
     LastEncryptionWriteTimeUtc = lastEncryptionWriteTimeUtc;
     Status = status;
 }
Esempio n. 52
0
        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.");
            }
        }
Esempio n. 53
0
 /// <summary>
 /// Add a file to the volatile file system state. To persist, call Save().
 /// </summary>
 /// <param name="activeFile">The active file to save</param>
 public void Add(ActiveFile activeFile)
 {
     if (activeFile == null)
     {
         throw new ArgumentNullException("activeFile");
     }
     lock (_lock)
     {
         AddInternal(activeFile);
     }
     OnChanged(new ActiveFileChangedEventArgs(activeFile));
 }
Esempio n. 54
0
 private static IRuntimeFileInfo GetTemporaryDestinationFolder(ActiveFile destinationActiveFile)
 {
     string destinationFolder;
     if (destinationActiveFile != null)
     {
         destinationFolder = Path.GetDirectoryName(destinationActiveFile.DecryptedFileInfo.FullName);
     }
     else
     {
         destinationFolder = Path.Combine(OS.Current.WorkFolder.FullName, Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + Path.DirectorySeparatorChar);
     }
     IRuntimeFileInfo destinationFolderInfo = OS.Current.FileInfo(destinationFolder);
     destinationFolderInfo.CreateFolder();
     return destinationFolderInfo;
 }
 public ActiveFileChangedEventArgs(ActiveFile activeFile)
 {
     ActiveFile = activeFile;
 }
        public static void TestActiveFileCollectionSimpleConstructor()
        {
            ActiveFileCollection collection = new ActiveFileCollection();

            IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_testTextPath);
            IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
            ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, new AesKey(), ActiveFileStatus.None, null);

            collection.Add(activeFile);

            Assert.That(collection.Count, Is.EqualTo(1), "There should be one entry in the collection.");

            foreach (ActiveFile member in collection)
            {
                Assert.That(member, Is.EqualTo(activeFile), "The one we added should now be in the collection.");
            }
        }
Esempio n. 57
0
        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;
        }
Esempio n. 58
0
        public static void TestInvalidArguments()
        {
            IRuntimeFileInfo nullFileInfo = null;
            ILauncher nullProcess = null;
            IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_testTextPath);
            IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
            AesKey key = new AesKey();
            AesKey nullKey = null;
            ILauncher process = new FakeLauncher(String.Empty);
            ActiveFile nullActiveFile = null;

            ActiveFile originalActiveFile = new ActiveFile(decryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, process);
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(nullActiveFile, key) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(originalActiveFile, nullKey) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(nullActiveFile, ActiveFileStatus.None, nullProcess) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(nullActiveFile, ActiveFileStatus.None) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(nullActiveFile, DateTime.MinValue, ActiveFileStatus.None) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(nullFileInfo, decryptedFileInfo, new AesKey(), ActiveFileStatus.None, nullProcess) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(encryptedFileInfo, nullFileInfo, new AesKey(), ActiveFileStatus.None, nullProcess) == null) { } });
            Assert.Throws<ArgumentNullException>(() => { if (new ActiveFile(encryptedFileInfo, decryptedFileInfo, nullKey, ActiveFileStatus.None, nullProcess) == null) { } });
        }
Esempio n. 59
0
        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;
        }
Esempio n. 60
0
        public static void TestThumbprint()
        {
            IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_testTextPath);
            IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_helloWorldAxxPath);
            ILauncher process = new FakeLauncher(String.Empty);

            AesKey key = new AesKey();

            using (MemoryStream stream = new MemoryStream())
            {
                DataContractSerializer serializer = new DataContractSerializer(typeof(ActiveFile));
                using (ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, process))
                {
                    serializer.WriteObject(stream, activeFile);
                }
                stream.Position = 0;
                ActiveFile deserializedActiveFile = (ActiveFile)serializer.ReadObject(stream);

                Assert.That(deserializedActiveFile.ThumbprintMatch(key), Is.True, "The deserialized object should match the thumbprint with the key.");
            }
        }