private async void DeleteVaultCommandAction(Object parameter) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Delete Vault command invoked."); VaultIndex vaultIndex = (VaultIndex)parameter; if (vaultIndex.IsInLocalVaultStore) { Boolean?deleted = VaultIndexFile.Instance.DeleteFromVault(vaultIndex); if (deleted.HasValue) { Vaults.Remove(vaultIndex); if (!deleted.Value) { await App.Controller.MainPageInstance.DisplayAlert("Delete Vault", "Successfully removed the vault from cachy, but failed to delete the vault file from the local vault store.", "OK"); } } else { await App.Controller.MainPageInstance.DisplayAlert("Delete Vault", "Failed to remove the vault from cachy.", "OK"); } NotifyPropertyChanged("IsEmpty"); NotifyPropertyChanged("ShowVaultListTip"); } else { await App.Controller.MainPageInstance.DisplayAlert("Delete Vault", "Only vaults that are stored in the local vault store can be deleted, you must remove this vault instead.", "OK"); } }
public async Task Synchronise(object parameter) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Synchronise invoked."); if (!IsSynchronising) { try { IsSynchronising = true; if (Vaults.Count > 0) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Performing auto cloud synchronisation."); VaultIndex opened = ((App)App.Current).OpenedVault; await CloudStorageSyncManager.Instance.UpdateAllVaultsSyncStatus(opened); await CloudStorageSyncManager.Instance.SyncAllVaults(opened); } else { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Skipping synchronisation as there are no vaults."); } } finally { IsSynchronising = false; } } }
public async void LocalVaultCommandAction(object parameter) { FileData file = await CrossFilePicker.Current.PickFile(new string[] { ".vault" }); if (file != null) { string destinationPath = file.FilePath; VaultIndex index = VaultIndex.Prepare(destinationPath); App.Controller.ShowPopup("vaultlist.unlockvault", new KeyValuePair <String, Object>("VaultIndex", index)); } }
public static CloudStorageProviderBase Create( IDLogger logger, VaultIndex vaultIndex, Dictionary <string, string> parameters) { if (vaultIndex.SyncMode == Common.SyncMode.CloudProvider) { string providerKey = parameters["ProviderKey"]; switch (providerKey) { case "Dropbox": { string accessToken = parameters["AccessToken"]; return(CreateOAuth <DropboxStorageProvider>( logger, accessToken)); } case "OneDrive": { string accessToken = parameters["AccessToken"]; return(CreateOAuth <OneDriveStorageProvider>( logger, accessToken)); } case "AmazonS3": { string accessID = parameters["AccessID"]; string secretKey = parameters["SecretKey"]; string region = parameters["Region"]; string bucketName = parameters["BucketName"]; string path = parameters["Path"]; return(CreateAmazon <AmazonS3StorageProvider>( logger, accessID, secretKey, region, bucketName, path)); } default: { throw new NotSupportedException(String.Format("Sync OAuth provider of type '{0}' not supported.", providerKey)); } } } else { return(null); } }
private void VaultInformationCommandAction(object parameter) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Vault information command invoked."); VaultIndex index = parameter as VaultIndex; if (index != null) { App.Controller.ShowPopup("vaultlist.vaultinfo", new KeyValuePair <string, object>("VaultIndex", index)); } }
public void SetParameter(String key, Object parameter) { switch (key) { case "VaultIndex": { _vaultIndex = (VaultIndex)parameter; ((App)App.Current).OpenedVault = _vaultIndex; break; } } }
private void RemoveVaultCommandAction(Object parameter) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Remove Vault command invoked."); VaultIndex vaultIndex = (VaultIndex)parameter; if (VaultIndexFile.Instance.RemoveFromVault(vaultIndex)) { Vaults.Remove(vaultIndex); NotifyPropertyChanged("IsEmpty"); NotifyPropertyChanged("ShowVaultListTip"); } }
private void VaultSelectedCommandAction(Object parameter) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information, "Vault Selected command invoked."); VaultIndex vaultIndex = (VaultIndex)parameter; if (vaultIndex != null) { IsUnlocking = true; App.Controller.ShowPopup("vaultlist.unlockvault", new KeyValuePair <String, Object>("VaultIndex", vaultIndex)); } }
public async void ProcessArguments(object parameter) { string commandLine = parameter as string; if (!String.IsNullOrEmpty(commandLine)) { if (commandLine.ToLower().EndsWith(".vault")) { if (await devoctomy.cachy.Framework.Native.Native.FileHandler.Exists(commandLine)) { VaultIndex index = VaultIndex.Prepare(commandLine); App.Controller.ShowPopup("vaultlist.unlockvault", new KeyValuePair <String, Object>("VaultIndex", index)); } } } }
private async Task <bool> TestVaultPassphrase( VaultIndex vaultIndex, string masterPassphrase) { Dictionary <string, string> parameters = new Dictionary <string, string>(); parameters.Add("KeyDerivationFunction", AppConfig.Instance.KeyDerivationFunction); switch (AppConfig.Instance.KeyDerivationFunction) { case AppConfig.CACHY_KEYDERIVATIONFUNCTION_PBKDF2: { parameters.Add("IterationCount", AppConfig.Instance.PBKDF2IterationCount.ToString()); break; } case AppConfig.CACHY_KEYDERIVATIONFUNCTION_SCRYPT: { parameters.Add("IterationCount", AppConfig.Instance.SCryptIterationCount.ToString()); parameters.Add("BlockSize", AppConfig.Instance.SCryptBlockSize.ToString()); parameters.Add("ThreadCount", AppConfig.Instance.SCryptThreadCount.ToString()); break; } } AESEncryptedVaultSerialiser serialiser = new AESEncryptedVaultSerialiser(); try { GenericResult <Common.LoadResult, Vault> loadResult = await vaultIndex.Load(serialiser, masterPassphrase, parameters.ToArray()); return(loadResult.Result == Common.LoadResult.Success); } catch (Exception ex) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Exception, "Failed to unlock the vault at '{0}'.\r\n'{1}'.", vaultIndex.FullPath, ex.Message); return(false); } }
public async void OnClosePopup(View item, object parameter) { App.AppLogger.Logger.Log(devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.Information | devoctomy.DFramework.Logging.Interfaces.LoggerMessageType.VerboseMed, "VaultListViewModel OnClosePopup."); if (item is UnlockView) { Dictionary <string, object> parameters = parameter as Dictionary <string, object>; if (parameters != null) { VaultIndex vaultIndex = (VaultIndex)parameters["VaultIndex"]; string masterPassphrase = (string)parameters["MasterPassphrase"]; if (await TestVaultPassphrase( vaultIndex, masterPassphrase)) { App.Controller.NavigateTo( "vault", parameters.ToArray()); } else { ((App)App.Current).OpenedVault = null; await App.Controller.MainPageInstance.DisplayAlert("Unlock Vault", String.Format("Failed to unlock the vault."), "OK"); } } ListView vaultsList = (ListView)View.FindByName("VaultsList"); vaultsList.SelectedItem = null; IsUnlocking = false; } else { ListView vaultsList = (ListView)View.FindByName("VaultsList"); vaultsList.SelectedItem = null; } }
public void SetParameter(String key, Object parameter) { switch (key) { case "Vault": { Vault = (Vault)parameter; Vault.PropertyChanged += _vault_PropertyChanged; NotifyPropertyChanged("Vault"); NotifyPropertyChanged("FilteredCredentials"); UpdatePageTitle(); ResetIdleTime(); ((App)App.Current).OpenedVault = VaultIndexFile.Instance.Indexes.FirstOrDefault(vi => vi.ID == Vault.ID); if (AppConfig.Instance.AutoCloseVault) { _autoLockTimer.Start(); } break; } case "VaultIndex": { //we should be sent this along with the master passphrase //if the vault is first being opened _vaultIndex = (VaultIndex)parameter; ((App)App.Current).OpenedVault = _vaultIndex; break; } case "MasterPassphrase": { _masterPassphrase = (String)parameter; break; } } }
public void OnClosePopup(View item, object parameter) { if (item is CloudProviderFileSelectView) { if (parameter != null) { CloudStorageProviderFileBase cloudFile = parameter as CloudStorageProviderFileBase; if (cloudFile != null) { String appDataPath = String.Empty; Directory.ResolvePath("{AppData}", out appDataPath); if (!appDataPath.EndsWith(DLoggerManager.PathDelimiter)) { appDataPath += DLoggerManager.PathDelimiter; } String vaultFullPath = String.Format("{0}{1}", appDataPath, String.Format(@"LocalVaults{0}{1}", DLoggerManager.PathDelimiter, cloudFile.Name)); string cloudFilePath = cloudFile.Path; IEnumerable <CloudProvider> providers = cachy.Config.CloudProviders.Instance.Providers.Where(cp => cp.ID == SelectedCloudProvider.ID); if (providers.Any()) { CloudProvider provider = providers.First(); switch (provider.AuthType) { case ProviderType.AuthenticationType.Amazon: { string secret = ((App)App.Current).GetCredential(SelectedCloudProvider.ID); JObject s3ConfigJSON = JObject.Parse(secret); AmazonS3Config s3Config = AmazonS3Config.FromJSON(s3ConfigJSON); if (cloudFilePath.StartsWith(s3Config.Path)) { cloudFilePath = cloudFilePath.Substring(s3Config.Path.Length); } break; } } } VaultIndex index = VaultIndexFile.Instance.CreateLocalVaultStoreIndex("Name", "Description", Common.SyncMode.CloudProvider, SelectedCloudProvider.ID, vaultFullPath, cloudFilePath); ClearSelectedProvider(true); ((App)App.Current).NavigateToVaultsList(); } } else { ClearSelectedProvider(true); } } else if (item is AddCloudProviderView) { if (parameter != null) { SelectedCloudProvider = (CloudProvider)parameter; } } }
private async Task <Boolean> UnlockVault() { if (VaultIndex != null && !String.IsNullOrEmpty(MasterPassphrase)) { try { Dictionary <string, string> parameters = new Dictionary <string, string>(); parameters.Add("KeyDerivationFunction", AppConfig.Instance.KeyDerivationFunction); switch (AppConfig.Instance.KeyDerivationFunction) { case AppConfig.CACHY_KEYDERIVATIONFUNCTION_PBKDF2: { parameters.Add("IterationCount", AppConfig.Instance.PBKDF2IterationCount.ToString()); break; } case AppConfig.CACHY_KEYDERIVATIONFUNCTION_SCRYPT: { parameters.Add("IterationCount", AppConfig.Instance.SCryptIterationCount.ToString()); parameters.Add("BlockSize", AppConfig.Instance.SCryptBlockSize.ToString()); parameters.Add("ThreadCount", AppConfig.Instance.SCryptThreadCount.ToString()); break; } } AESEncryptedVaultSerialiser serialiser = new AESEncryptedVaultSerialiser(); GenericResult <Common.LoadResult, Vault> loadResult = await _vaultIndex.Load(serialiser, MasterPassphrase, parameters.ToArray()); _masterPassphrase = String.Empty; if (loadResult.Result == Common.LoadResult.Success) { Vault = loadResult.Value; Vault.PropertyChanged += _vault_PropertyChanged; if (!_vaultIndex.IsInLocalVaultStore && !VaultIndexFile.Instance.VaultIsIndexed(_vault)) { if (VaultIndex.SyncMode == Common.SyncMode.CloudProvider) { throw new NotImplementedException("Adding existing cloud provider vaults is not currently supported."); } VaultIndexFile.Instance.AddVaultToLocalVaultStoreIndex(_vault, VaultIndex.SyncMode, VaultIndex.Provider, String.Empty, false); } NotifyPropertyChanged("Vault"); NotifyPropertyChanged("FilteredCredentials"); UpdatePageTitle(); ResetIdleTime(); if (_vaultIndex.Unopened) { //Mark it as opened and update the name and description _vaultIndex.MarkAsOpened( _vault.Name, _vault.Description); VaultIndexFile.Instance.Save(); } _vaultIndex = null; if (AppConfig.Instance.AutoCloseVault) { _autoLockTimer.Start(); } return(true); } else { return(false); } } catch (Exception ex) { await App.Controller.MainPageInstance.DisplayAlert("Unlock Vault", String.Format("Failed to unlock the vault, {0}.", ex.Message), "OK"); ((App)App.Current).NavigateToVaultsList(); return(false); } } else { return(false); } }
public async Task SyncVault(VaultIndex index) { if (index.SyncMode == Common.SyncMode.CloudProvider) { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "CloudStorageSyncManager Synchronising vault '{0}'.", index.ID); CloudStorageProviderBase provider = null; if (_providers.ContainsKey(index)) { provider = _providers[index]; } else { return; } try { switch (index.SyncStatus.Status) { case CloudProviderSyncStatus.SyncStatus.NoLocalCopyExists: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "Vault sync status is 'NoLocalCopyExists', so downloading cloud copy."); CloudProviderResponse <byte[]> getFileResponse = await provider.GetFileInMemory(index.CloudProviderPath); await Native.Native.FileHandler.WriteAsync( index.FullPath, getFileResponse.Result); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UpToDate); break; } case CloudProviderSyncStatus.SyncStatus.CloudCopyNewer: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "Vault sync status is 'CloudCopyNewer', so downloading cloud copy."); CloudProviderResponse <byte[]> gutFileResponse = await provider.GetFileInMemory(index.CloudProviderPath); await Native.Native.FileHandler.WriteAsync( index.FullPath, gutFileResponse.Result); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UpToDate); break; } case CloudProviderSyncStatus.SyncStatus.LocalCopyNewer: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "Vault sync status is 'LocalCopyNewer', so uploading local copy."); byte[] fileData = await Native.Native.FileHandler.ReadAsync(index.FullPath); CloudProviderResponse <bool> putFileResponse = await provider.PutFile( fileData, index.CloudProviderPath, true); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UpToDate); break; } case CloudProviderSyncStatus.SyncStatus.NoCloudCopyExists: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "Vault sync status is 'NoCloudCopyExists', so uploading local copy."); byte[] fileData = await Native.Native.FileHandler.ReadAsync(index.FullPath); CloudProviderResponse <bool> putFileResponse = await provider.PutFile( fileData, index.CloudProviderPath, false); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UpToDate); break; } case CloudProviderSyncStatus.SyncStatus.UpToDate: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseHigh | LoggerMessageType.Information, "CloudStorageSyncManager Vault '{0}' is up to date.", index.ID); break; } default: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Error, "CloudStorageSyncManager Unknown cloud sync status of '{0}'.", index.SyncStatus.Status); break; } } } catch (Exception ex) { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Error, "CloudStorageSyncManager Unknown error whilst synchronising vault '{0}'.", index.ID); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UnknownError); } } }
public CloudProviderSyncStatus(VaultIndex vaultIndex) { _vaultIndex = vaultIndex; }
public async Task UpdateVaultSyncStatus(VaultIndex index) { if (index.SyncMode == Common.SyncMode.CloudProvider) { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "CloudStorageSyncManager Updating vault sync status of vault '{0}'.", index.ID); CloudStorageProviderBase storageProvider = null; if (_providers.ContainsKey(index)) { storageProvider = _providers[index]; } else { string authType = _getProviderValueCallback(index.Provider, "AuthType").ToString(); switch (authType) { case "OAuth": { string providerKey = (string)_getProviderValueCallback(index.Provider, "ProviderKey"); string accessToken = _getCredentialCallback(index.Provider); if (!String.IsNullOrEmpty(accessToken)) { Dictionary <string, string> parameters = new Dictionary <string, string>(); parameters.Add("AuthType", "OAuth"); parameters.Add("ProviderKey", providerKey); parameters.Add("AccessToken", accessToken); storageProvider = CloudStorageProviderBase.Create( _logger, index, parameters); _providers.Add(index, storageProvider); } else { index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.AuthenticationError, "The OAuth credentials for the associated cloud provider could not be retrieved. This may have be caused by uninstalling / reinstalling cachy. To fix this, re-authenticate with the cloud provider through the application settings 'SYNC' menu."); return; } break; } case "Amazon": { string providerKey = (string)_getProviderValueCallback(index.Provider, "ProviderKey"); string secret = _getCredentialCallback(index.Provider); if (!String.IsNullOrEmpty(secret)) { JObject s3ConfigJSON = JObject.Parse(secret); AmazonS3Config s3Config = AmazonS3Config.FromJSON(s3ConfigJSON); Dictionary <string, string> createParams = s3Config.ToDictionary(); createParams.Add("ProviderKey", providerKey); storageProvider = CloudStorageProviderBase.Create( DLoggerManager.Instance.Logger, createParams); _providers.Add(index, storageProvider); } else { index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.AuthenticationError, "The OAuth credentials for the associated cloud provider could not be retrieved. This may have be caused by uninstalling / reinstalling cachy. To fix this, re-authenticate with the cloud provider through the application settings 'SYNC' menu."); return; } break; } } } CloudProviderResponse <CloudStorageProviderFileBase> fileResponse = await storageProvider.GetFileInfo(index.CloudProviderPath); switch (fileResponse.ResponseValue) { case CloudProviderResponse <CloudStorageProviderFileBase> .Response.Success: { //does our local file exist? if (System.IO.File.Exists(index.FullPath)) { if (!index.LastModified.HasValue) { index.UpdateLastModified(); if (!index.LastModified.HasValue) { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Information, "CloudStorageSyncManager Uknown error for vault '{0}'.", index.ID); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UnknownError); break; } } CloudStorageProviderFileBase remote = fileResponse.Result; string currenthash = await Native.Native.FileHandler.HashFileAsync( GetHashStyleFromProviderKey(storageProvider.TypeName), index.FullPath); bool hashesMatch = currenthash == remote.Hash; if (hashesMatch) { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseHigh | LoggerMessageType.Information, "CloudStorageSyncManager Vault '{0}' is up to date.", index.ID); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UpToDate); } else { //These dates will *never* match index.SyncStatus.SetStatus(remote.LastModified > index.LastModified ? CloudProviderSyncStatus.SyncStatus.CloudCopyNewer : CloudProviderSyncStatus.SyncStatus.LocalCopyNewer); } } else { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Warning, "CloudStorageSyncManager Local copy does not exist for vault '{0}'.", index.ID); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.NoLocalCopyExists); } break; } case CloudProviderResponse <CloudStorageProviderFileBase> .Response.NotFound: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Warning, "CloudStorageSyncManager File not found in cloud for vault '{0}', provider type '{1}'.", index.ID, storageProvider.TypeName); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.NoCloudCopyExists); break; } case CloudProviderResponse <CloudStorageProviderFileBase> .Response.AuthenticationError: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Error, "CloudStorageSyncManager Authentication error for cloud provider type '{0}'.", storageProvider.TypeName); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.AuthenticationError, "The OAuth credentials for the associated cloud provider are invalid. To fix this, re-authenticate with the cloud provider through the application settings 'SYNC' menu."); break; } case CloudProviderResponse <CloudStorageProviderFileBase> .Response.UnknownError: { DLoggerManager.Instance.Logger.Log(LoggerMessageType.VerboseLow | LoggerMessageType.Error, "CloudStorageSyncManager Unknown error for cloud provider type '{0}'.", storageProvider.TypeName); index.SyncStatus.SetStatus(CloudProviderSyncStatus.SyncStatus.UnknownError); break; } } } }