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;
}
}
}
}
