public void TestInvalidArguments()
{
string file = _helloWorldAxxPath;
IDataStore dataStore = New <IDataStore>(file);
IDataStore nullDataStore = null;
IEnumerable <LogOnIdentity> keys = new LogOnIdentity[] { new LogOnIdentity("a") };
IEnumerable <LogOnIdentity> nullKeys = null;
ProgressContext context = new ProgressContext();
ProgressContext nullContext = null;
FileOperation fileOperation = new FileOperation(Resolve.FileSystemState, new SessionNotify());
Assert.ThrowsAsync <ArgumentNullException>(async() => { await fileOperation.OpenAndLaunchApplication(keys, nullDataStore, context); }, "The data store is null.");
Assert.ThrowsAsync <ArgumentNullException>(async() => { await fileOperation.OpenAndLaunchApplication(nullKeys, dataStore, context); }, "The keys are null.");
Assert.ThrowsAsync <ArgumentNullException>(async() => { await fileOperation.OpenAndLaunchApplication(keys, dataStore, nullContext); }, "The context is null.");
}
public void TestInvalidArguments()
{
IDataStore nullFileInfo = null;
IDataStore decryptedFileInfo = New <IDataStore>(_testTextPath);
IDataStore encryptedFileInfo = New <IDataStore>(_helloWorldAxxPath);
LogOnIdentity key = new LogOnIdentity("key");
LogOnIdentity nullKey = null;
ActiveFile nullActiveFile = null;
ActiveFile originalActiveFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, new V1Aes128CryptoFactory().CryptoId);
Assert.Throws <ArgumentNullException>(() => { if (new ActiveFile(nullActiveFile) == null)
{
}
});
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) == null)
{
}
});
Assert.Throws <ArgumentNullException>(() => { if (new ActiveFile(nullActiveFile, DateTime.MinValue, ActiveFileStatus.None) == null)
{
}
});
Assert.Throws <ArgumentNullException>((TestDelegate)(() => { if (new ActiveFile(nullFileInfo, decryptedFileInfo, new LogOnIdentity("a"), ActiveFileStatus.None, (Guid) new V1Aes128CryptoFactory().CryptoId) == null)
{
}
}));
Assert.Throws <ArgumentNullException>((TestDelegate)(() => { if (new ActiveFile(encryptedFileInfo, nullFileInfo, new LogOnIdentity("b"), ActiveFileStatus.None, (Guid) new V1Aes128CryptoFactory().CryptoId) == null)
{
}
}));
Assert.Throws <ArgumentNullException>((TestDelegate)(() => { if (new ActiveFile(encryptedFileInfo, decryptedFileInfo, nullKey, ActiveFileStatus.None, (Guid) new V1Aes128CryptoFactory().CryptoId) == null)
{
}
}));
}
public async Task TestCheckActiveFilesUpdateButWithTargetLockedForSharing()
{
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;
return(Constant.CompletedTask);
});
try
{
FakeDataStore.IsLockedFunc = (fds) => fds.FullName == _decryptedFile1;
await New <ActiveFileAction>().CheckActiveFiles(new ProgressContext());
}
finally
{
FakeDataStore.IsLockedFunc = (fds) => false;
}
Assert.That(changedWasRaised, Is.True, "The ActiveFile should be modified because it should now be marked as not shareable.");
activeFile = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(_anAxxPath);
Assert.That(activeFile.Status.HasMask(ActiveFileStatus.NotShareable), Is.True, "The ActiveFile should be marked as not shareable after the checking of active files.");
}
public async Task AskForLogOnPassphraseActionWithCancel()
{
LogOnIdentity key = new LogOnIdentity("ppp");
LogOnIdentity id = key;
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
e.Cancel = true;
return(Task.FromResult <object>(null));
};
await ivm.AskForLogOnPassphrase.ExecuteAsync(id);
Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty);
Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity == LogOnIdentity.Empty);
}
public async Task TestClear()
{
KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify);
LogOnIdentity key1 = new LogOnIdentity("key1");
await knownIdentities.AddAsync(key1);
LogOnIdentity key2 = new LogOnIdentity("key2");
await knownIdentities.AddAsync(key2);
Assert.That(knownIdentities.Identities.Count(), Is.EqualTo(2), "There should be two keys in the collection.");
await knownIdentities.SetDefaultEncryptionIdentity(LogOnIdentity.Empty);
Assert.That(knownIdentities.Identities.Count(), Is.EqualTo(0), "There should be zero keys in the collection after Clear().");
await knownIdentities.SetDefaultEncryptionIdentity(LogOnIdentity.Empty);
Assert.That(knownIdentities.Identities.Count(), Is.EqualTo(0), "There should be zero keys in the collection after Clear() with zero keys to start with.");
}
public async Task TestWatchedFoldersWhenLoggedOn()
{
Passphrase key1 = new Passphrase("a");
LogOnIdentity key2 = new LogOnIdentity("b");
KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, Resolve.SessionNotify);
FakeDataStore.AddFolder(@"C:\WatchedFolder1\");
FakeDataStore.AddFolder(@"C:\WatchedFolder2\");
await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder1\", new LogOnIdentity(key1).Tag));
await Resolve.FileSystemState.AddWatchedFolderAsync(new WatchedFolder(@"C:\WatchedFolder2\", key2.Tag));
await knownIdentities.SetDefaultEncryptionIdentity(key2);
IEnumerable <WatchedFolder> watchedFolders = knownIdentities.LoggedOnWatchedFolders;
Assert.That(watchedFolders.Count(), Is.EqualTo(1), "Only one of the two watched folders should be shown.");
Assert.That(watchedFolders.First().Tag.Matches(key2.Tag), "The returned watched folder should be number 2.");
}
public async Task ChangeEncryptionAsync(IEnumerable <IDataStore> files, LogOnIdentity identity, EncryptionParameters encryptionParameters, IProgressContext progress)
{
if (progress == null)
{
throw new ArgumentNullException(nameof(progress));
}
if (files == null)
{
throw new ArgumentNullException(nameof(files));
}
progress.AddTotal(files.Count());
foreach (IDataStore file in files)
{
await ChangeEncryptionAsync(file, identity, encryptionParameters, progress);
progress.AddCount(1);
}
}
public async Task TestAddAndRemoveWatchedFolderState()
{
var fileSystemStateMock = new Mock <FileSystemState>()
{
CallBase = true
};
fileSystemStateMock.Setup(x => x.Save()).Returns(Constant.CompletedTask);
TypeMap.Register.Singleton <FileSystemState>(() => fileSystemStateMock.Object);
using (MainViewModel mvm = New <MainViewModel>())
{
Assert.ThrowsAsync <InvalidOperationException>(async() => await mvm.DecryptWatchedFolders.ExecuteAsync(new string[] { }));
LogOnIdentity id = new LogOnIdentity("passphrase");
fileSystemStateMock.Object.KnownPassphrases.Add(id.Passphrase);
await Resolve.KnownIdentities.SetDefaultEncryptionIdentity(id);
fileSystemStateMock.ResetCalls();
await mvm.DecryptWatchedFolders.ExecuteAsync(new string[] { });
fileSystemStateMock.Verify(x => x.RemoveAndDecryptWatchedFolder(It.IsAny <IDataContainer>()), Times.Never);
fileSystemStateMock.Verify(x => x.Save(), Times.Never);
fileSystemStateMock.ResetCalls();
await mvm.AddWatchedFolders.ExecuteAsync(new string[] { });
fileSystemStateMock.Verify(x => x.AddWatchedFolderAsync(It.IsAny <WatchedFolder>()), Times.Never);
fileSystemStateMock.Verify(x => x.Save(), Times.Never);
await mvm.AddWatchedFolders.ExecuteAsync(new string[] { @"C:\Folder1\", @"C:\Folder2\" });
fileSystemStateMock.Verify(x => x.AddWatchedFolderAsync(It.IsAny <WatchedFolder>()), Times.Exactly(2));
fileSystemStateMock.Verify(x => x.Save(), Times.Once);
fileSystemStateMock.ResetCalls();
await mvm.DecryptWatchedFolders.ExecuteAsync(new string[] { @"C:\Folder1\" });
}
fileSystemStateMock.Verify(x => x.RemoveAndDecryptWatchedFolder(It.IsAny <IDataContainer>()), Times.Exactly(1));
fileSystemStateMock.Verify(x => x.Save(), Times.Once);
}
public async Task TestSetDefaultEncryptionKeyWithoutIdentity()
{
var fileSystemStateMock = new Mock <FileSystemState>()
{
CallBase = true
};
fileSystemStateMock.Setup(x => x.Save());
TypeMap.Register.Singleton <FileSystemState>(() => fileSystemStateMock.Object);
using (MainViewModel mvm = New <MainViewModel>())
{
LogOnIdentity identity = new LogOnIdentity("passphrase");
Assert.That(!Resolve.FileSystemState.KnownPassphrases.Any(kp => kp.Thumbprint == identity.Passphrase.Thumbprint));
await Resolve.KnownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity("passphrase"));
Assert.That(Resolve.FileSystemState.KnownPassphrases.Any(kp => kp.Thumbprint == identity.Passphrase.Thumbprint));
}
}
private async Task <LogOnIdentity> AskForDecryptPassphraseActionAsync(string encryptedFileFullName)
{
LogOnEventArgs logOnArgs = new LogOnEventArgs()
{
DisplayPassphrase = _userSettings.DisplayEncryptPassphrase,
Identity = LogOnIdentity.Empty,
EncryptedFileFullName = encryptedFileFullName,
};
await OnLoggingOnAsync(logOnArgs);
LogOnIdentity identy = await AddKnownIdentityFromEventAsync(logOnArgs);
if (!_knownIdentities.IsLoggedOn && identy.UserEmail != EmailAddress.Empty)
{
await _knownIdentities.SetDefaultEncryptionIdentity(identy);
}
return(identy);
}
public async Task AskForLogOnPassphraseAction()
{
LogOnIdentity key = new LogOnIdentity("ppp");
LogOnIdentity id = key;
IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
ivm.LoggingOnAsync = (e) =>
{
e.Passphrase = new Passphrase("ppp");
e.IsAskingForPreviouslyUnknownPassphrase = true;
return(Task.FromResult <object>(null));
};
await ivm.AskForLogOnPassphrase.ExecuteAsync(id);
Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("ppp"));
Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(id.Passphrase.Thumbprint));
}
public static EncryptedProperties Create(IDataStore encrypted, LogOnIdentity identity)
{
if (encrypted == null)
{
throw new ArgumentNullException("encrypted");
}
try
{
using (Stream stream = encrypted.OpenRead())
{
return(Create(stream, identity));
}
}
catch (FileNotFoundException fnfex)
{
New <IReport>().Exception(fnfex);
return(Invalid);
}
}
public async Task TestDecryptFilesUniqueWithWipeOfOriginal()
{
TypeMap.Register.Singleton <ParallelFileOperation>(() => new ParallelFileOperation());
TypeMap.Register.Singleton <IProgressBackground>(() => new FakeProgressBackground());
IDataStore sourceFileInfo = New <IDataStore>(_helloWorldAxxPath);
IDataContainer sourceFolderInfo = New <IDataContainer>(Path.GetDirectoryName(sourceFileInfo.FullName));
IDataStore destinationFileInfo = New <IDataStore>(Path.Combine(Path.GetDirectoryName(_helloWorldAxxPath), "HelloWorld-Key-a.txt"));
LogOnIdentity passphrase = new LogOnIdentity("a");
Mock <IStatusChecker> mockStatusChecker = new Mock <IStatusChecker>();
Assert.That(sourceFileInfo.IsAvailable, Is.True, "The source should exist.");
Assert.That(destinationFileInfo.IsAvailable, Is.False, "The source should not exist yet.");
await New <AxCryptFile>().DecryptFilesInsideFolderUniqueWithWipeOfOriginalAsync(sourceFolderInfo, passphrase, mockStatusChecker.Object, new ProgressContext());
Assert.That(sourceFileInfo.IsAvailable, Is.False, "The source should be wiped.");
Assert.That(destinationFileInfo.IsAvailable, Is.True, "The destination should be created and exist now.");
}
public async Task TestChangedEvent()
{
bool wasChanged = false;
SessionNotify notificationMonitor = new SessionNotify();
KnownIdentities knownIdentities = new KnownIdentities(Resolve.FileSystemState, notificationMonitor);
notificationMonitor.AddCommand((SessionNotification notification) =>
{
wasChanged |= notification.NotificationType == SessionNotificationType.KnownKeyChange;
return(Constant.CompletedTask);
});
LogOnIdentity key1 = new LogOnIdentity("abc");
await knownIdentities.AddAsync(key1);
Assert.That(wasChanged, Is.True, "A new key should trigger the Changed event.");
wasChanged = false;
await knownIdentities.AddAsync(key1);
Assert.That(wasChanged, Is.False, "Re-adding an existing key should not trigger the Changed event.");
}
public async Task TestRemoveRecentFileWhenFileDoesNotExist()
{
IDataStore encryptedFileInfo = New <IDataStore>(_anAxxPath);
IDataStore decryptedFileInfo = New <IDataStore>(_decryptedFile1);
LogOnIdentity key = new LogOnIdentity("passphrase");
ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.NotShareable, new V2Aes256CryptoFactory().CryptoId);
Resolve.FileSystemState.Add(activeFile);
await Resolve.FileSystemState.Save();
ActiveFile beforeRemoval = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(encryptedFileInfo.FullName);
Assert.That(beforeRemoval, Is.Not.Null, "Before being removed, the ActiveFile should be possible to find.");
Assert.DoesNotThrowAsync(async() => { await New <ActiveFileAction>().RemoveRecentFiles(new IDataStore[] { New <IDataStore>(encryptedFileInfo.FullName + ".notfound") }, new ProgressContext()); });
ActiveFile afterFailedRemoval = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(encryptedFileInfo.FullName);
Assert.That(afterFailedRemoval, Is.Not.Null, "After failed removal, the ActiveFile should still be possible to find.");
}
public async Task TestSimpleOpenAndLaunch()
{
IDataStore dataStore = New <IDataStore>(_helloWorldAxxPath);
IEnumerable <LogOnIdentity> keys = new LogOnIdentity[] { new LogOnIdentity("a") };
var mock = new Mock <ILauncher>()
{
CallBase = true
};
string launcherPath = null;
mock.Setup(x => x.Launch(It.IsAny <string>())).Callback((string path) => launcherPath = path);
TypeMap.Register.New <ILauncher>(() => mock.Object);
FileOperation fileOperation = new FileOperation(Resolve.FileSystemState, new SessionNotify());
FileOperationContext status = await fileOperation.OpenAndLaunchApplication(keys, dataStore, new ProgressContext());
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The launch should succeed.");
Assert.DoesNotThrow(() => mock.Verify(x => x.Launch(launcherPath)));
}
private bool AddInternal(LogOnIdentity identity)
{
if (identity == LogOnIdentity.Empty)
{
return(false);
}
bool changed = false;
lock (_logOnIdentities)
{
int i = _logOnIdentities.IndexOf(identity);
if (i < 0)
{
_logOnIdentities.Insert(0, identity);
changed = true;
}
}
changed |= AddKnownThumbprint(identity);
return(changed);
}
private void DoAuthentication()
{
ITicket ticket;
string logonName = InternalGetLogOnName(out ticket);
if (logonName.IsNotEmpty())
{
logonName = ImpersonateSettings.GetConfig().Impersonation[logonName];
LogOnIdentity loi = new LogOnIdentity(logonName);
if (ticket != null)
{
ticket.SignInInfo.UserID = loi.LogOnNameWithDomain;
}
SetTenantContext(ticket);
SetPrincipal(loi.LogOnNameWithDomain, ticket);
}
}
public static bool IsAnyFileKeyKnown(this IEnumerable <IDataStore> files)
{
foreach (IDataStore fileInfo in files)
{
try
{
Guid cryptoId;
LogOnIdentity logOnIdentity = fileInfo.TryFindPassphrase(out cryptoId);
if (logOnIdentity != null)
{
return(true);
}
}
catch (FileOperationException)
{
continue;
}
}
return(false);
}
private async Task ImportFileActionAsync()
{
IDataStore privateKeyData = New <IDataStore>(PrivateKeyFileName);
Passphrase passphrase = new Passphrase(PasswordText);
UserKeyPair keyPair;
if (!UserKeyPair.TryLoad(privateKeyData.ToArray(), passphrase, out keyPair))
{
ImportSuccessful = false;
return;
}
LogOnIdentity identity = new LogOnIdentity(keyPair.UserEmail, passphrase);
AccountStorage store = new AccountStorage(New <LogOnIdentity, IAccountService>(identity));
await store.ImportAsync(keyPair);
ImportSuccessful = true;
_userSettings.UserEmail = keyPair.UserEmail.Address;
await _knownIdentities.SetDefaultEncryptionIdentity(new LogOnIdentity(await store.AllKeyPairsAsync(), passphrase));
}
private bool AuthenticateAlternativeUserIDs(IEnumerable <string> alternativeUserIDs, string password, Dictionary <string, object> context)
{
bool result = false;
if (alternativeUserIDs != null)
{
foreach (string userID in alternativeUserIDs)
{
LogOnIdentity loi = new LogOnIdentity(userID, password);
result = AuthenticateUser(loi);
if (result)
{
break;
}
}
}
return(result);
}
public async Task TestHandleSessionEventWatchedFolderAdded(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 = folderInfos.First().FullName == @"C:\My Documents\".NormalizeFilePath(); };
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));
await handler.HandleNotificationAsync(new SessionNotification(SessionNotificationType.WatchedFolderAdded, new LogOnIdentity("passphrase"), @"C:\My Documents\"));
Assert.That(called, Is.True);
}
public static void RestoreRandomRename(this IDataStore dataStore, LogOnIdentity identity)
{
EncryptedProperties encryptedProperties = EncryptedProperties.Create(dataStore, identity);
if (!encryptedProperties.IsValid)
{
return;
}
string destinationFilePath = Resolve.Portable.Path().Combine(Resolve.Portable.Path().GetDirectoryName(dataStore.FullName), encryptedProperties.FileMetaData.FileName.CreateEncryptedName());
if (string.Equals(dataStore.FullName, destinationFilePath, StringComparison.OrdinalIgnoreCase))
{
return;
}
using (FileLock lockedSave = destinationFilePath.CreateUniqueFile())
{
dataStore.MoveTo(lockedSave.DataStore.FullName);
}
}
private static IPrincipal SetPrincipal(string userID, ITicket ticket)
{
IPrincipal principal = GetPrincipalInSession(userID);
if (principal == null)
{
LogOnIdentity loi = new LogOnIdentity(userID);
string identityID = string.Empty;
if (PassportClientSettings.GetConfig().IdentityWithoutDomainName)
{
identityID = loi.LogOnNameWithoutDomain;
}
else
{
identityID = loi.LogOnName;
}
principal = PrincipalSettings.GetConfig().GetPrincipalBuilder().CreatePrincipal(identityID, ticket);
HttpCookie cookie = new HttpCookie(Common.GetPrincipalSessionKey());
cookie.Expires = DateTime.MinValue;
CookieCacheDependency cookieDependency = new CookieCacheDependency(cookie);
SlidingTimeDependency slidingDependency =
new SlidingTimeDependency(Common.GetSessionTimeOut());
PrincipalCache.Instance.Add(
Common.GetPrincipalSessionKey(),
principal,
new MixedDependency(cookieDependency, slidingDependency));
}
PrincipaContextAccessor.SetPrincipal(principal);
return(principal);
}
protected override async Task <PlanState> TryPremium(LogOnIdentity identity, PlanInformation planInformation, NameOf startTrialMessage)
{
if (planInformation.PlanState != PlanState.CanTryPremium)
{
return(planInformation.PlanState);
}
string messageText = Texts.MessageAskAboutStartTrial + Environment.NewLine + Environment.NewLine + Texts.ResourceManager.GetString(startTrialMessage.Name);
string result = await New <IPopup>().ShowAsync(new string[] { Texts.ButtonStartTrial, Texts.ButtonNotNow }, Texts.WelcomeMailSubject, messageText, DoNotShowAgainOptions.TryPremium);
if (result != Texts.ButtonStartTrial)
{
return(planInformation.PlanState);
}
if (!await StartTrial(identity))
{
return(PlanState.CanTryPremium);
}
return(PlanState.HasPremium);
}
/// <summary>
/// 调用认证接口
/// </summary>
/// <param name="strSignInName">登录名</param>
/// <param name="strPasspord">密码</param>
/// <returns>用户认证的结果</returns>
private ISignInUserInfo DefaultAuthenticate(string strSignInName, string strPasspord)
{
LogOnIdentity loi = new LogOnIdentity(strSignInName, strPasspord);
OnBeforeAuthenticate(loi);
ISignInUserInfo result = null;
IAuthenticator2 auth2 = this.GetAuthenticator2();
if (auth2 != null)
{
SignInPerformanceCounters.DoAction(() => result = auth2.Authenticate(loi.LogOnName, loi.Password, loi.Context));
}
else
{
IAuthenticator auth = GetAuthenticator();
SignInPerformanceCounters.DoAction(() => result = auth.Authenticate(loi.LogOnName, loi.Password));
}
return(result);
}
public async Task TestUpdateActiveFileWithEventRaisedSinceItAppearsAProcessHasExited()
{
IDataStore encryptedFileInfo = New <IDataStore>(_anAxxPath);
IDataStore decryptedFileInfo = New <IDataStore>(_decryptedFile1);
LogOnIdentity key = new LogOnIdentity("passphrase");
ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId);
Resolve.FileSystemState.Add(activeFile);
((FakeNow)New <INow>()).TimeFunction = (() => { return(DateTime.UtcNow.AddMinutes(1)); });
bool changedWasRaised = false;
Resolve.SessionNotify.AddCommand((SessionNotification notification) =>
{
changedWasRaised = notification.NotificationType == SessionNotificationType.ActiveFileChange;
return(Constant.CompletedTask);
});
await New <ActiveFileAction>().CheckActiveFiles(new ProgressContext());
Assert.That(changedWasRaised, Is.True, "An event should be raised, because status was NotShareable, but no process is active.");
}
private async Task <LogOnIdentity> AddKnownIdentityFromEventAsync(LogOnEventArgs logOnArgs)
{
if (logOnArgs.Cancel || logOnArgs.Passphrase == Passphrase.Empty)
{
return(LogOnIdentity.Empty);
}
_userSettings.DisplayEncryptPassphrase = logOnArgs.DisplayPassphrase;
Passphrase passphrase = logOnArgs.Passphrase;
LogOnIdentity identity = await LogOnIdentityFromCredentialsAsync(EmailAddress.Parse(logOnArgs.UserEmail), passphrase);
if (identity == LogOnIdentity.Empty)
{
identity = new LogOnIdentity(passphrase);
_fileSystemState.KnownPassphrases.Add(passphrase);
await _fileSystemState.Save();
}
await _knownIdentities.AddAsync(identity);
return(identity);
}
public async Task TestUpdateActiveFileButWithNoChangeDueToIrrelevantStatus()
{
IDataStore encryptedFileInfo = New <IDataStore>(_anAxxPath);
IDataStore decryptedFileInfo = New <IDataStore>(_decryptedFile1);
LogOnIdentity key = new LogOnIdentity("passphrase");
ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.None, new V1Aes128CryptoFactory().CryptoId);
Resolve.FileSystemState.Add(activeFile);
((FakeNow)New <INow>()).TimeFunction = (() => { return(DateTime.UtcNow.AddMinutes(1)); });
bool changedWasRaised = false;
Resolve.SessionNotify.AddCommand((SessionNotification notification) =>
{
changedWasRaised = notification.NotificationType == SessionNotificationType.ActiveFileChange;
return(Constant.CompletedTask);
});
await New <ActiveFileAction>().CheckActiveFiles(new ProgressContext());
Assert.That(changedWasRaised, Is.False, "No event should be raised, because nothing should change.");
}
public async Task TestRemoveRecentFile()
{
IDataStore encryptedFileInfo = New <IDataStore>(_anAxxPath);
IDataStore decryptedFileInfo = New <IDataStore>(_decryptedFile1);
LogOnIdentity key = new LogOnIdentity("passphrase");
ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId);
Resolve.FileSystemState.Add(activeFile);
await Resolve.FileSystemState.Save();
ActiveFile beforeRemoval = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(encryptedFileInfo.FullName);
Assert.That(beforeRemoval, Is.Not.Null, "Before being removed, the ActiveFile should be possible to find.");
activeFile = new ActiveFile(activeFile, ActiveFileStatus.NotDecrypted);
Resolve.FileSystemState.Add(activeFile);
await New <ActiveFileAction>().RemoveRecentFiles(new IDataStore[] { New <IDataStore>(encryptedFileInfo.FullName) }, new ProgressContext());
ActiveFile afterRemoval = Resolve.FileSystemState.FindActiveFileFromEncryptedPath(encryptedFileInfo.FullName);
Assert.That(afterRemoval, Is.Null, "After being removed, the ActiveFile should not be possible to find.");
}
