private async void SaveAsExe(object obj)
{
try
{
UserDialogsService.ShowLoading("Zapisywanie...");
FileObject fo;
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
await Task.Run(async() =>
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
if (obj is FileObject)
{
fo = obj as FileObject;
}
else
{
return;
}
var bytes = default(byte[]);
var DecryptedData = default(byte[]);
using (var streamReader = new StreamReader(fo.FilePath))
{
using (var memstream = new MemoryStream())
{
streamReader.BaseStream.CopyTo(memstream);
bytes = memstream.ToArray();
}
}
switch (fo.FileEncryptionMethod)
{
case CryptMethod.AES:
DecryptedData = _AES.Decrypt(bytes, fo.FileDecryptionPassword);
break;
case CryptMethod.DES:
DecryptedData = _DES.Decrypt(bytes, fo.FileDecryptionPassword);
break;
case CryptMethod.TripleDES:
DecryptedData = _3DES.Decrypt(bytes, fo.FileDecryptionPassword);
break;
default:
break;
}
DependencyService.Get <ISaveFile>().SaveFile(DecryptedData, fo.FileName);
UserDialogsService.HideLoading();
});
}
catch (Exception)
{
UserDialogsService.HideLoading();
UserDialogs.Instance.Alert("Zapisywanie zakończone nipowodzeniem.", "Błąd");
}
}
private async void onLanguageChange(string obj)
{
UserDialogsService.ShowLoading(TranslateService.ProvideValue("Loading"));
CrossMultilingual.Current.CurrentCultureInfo = new CultureInfo(obj);
AppResources.Culture = CrossMultilingual.Current.CurrentCultureInfo;
await NavigationService.UpdagePagesLanguage();
UserDialogsService.HideLoading();
}
private async void LoginExe()
{
using (UserDialogs.Instance.Loading(TranslateService.ProvideValue("Loading")))
if (CheckCredentials())
{
//await Task.Delay(1500);
App.IsUserLoggedIn = true;
await NavigationService.InsertNewRootPage("MainPage");
}
else
{
UserDialogsService.ShowAltert(TranslateService.ProvideValue("Message_WrongPassword"), TranslateService.ProvideValue("Message_LoginError"));
}
}
//private DelegateCommand _refreshCommand;
//public DelegateCommand RefreshCommand =>
// _refreshCommand ?? (_refreshCommand = new DelegateCommand(async () => await ExecuteRefreshCommand()));
//private async Task ExecuteRefreshCommand()
//{
// IsRefreshing = true;
// await GetBlutoothDevices();
// IsRefreshing = false;
//}
private async Task ExecuteItemSelectedCommand(IDevice device)
{
try
{
UserDialogsService.ShowLoading("Connect To Device", MaskType.Gradient);
await _adapterService.ConnectToDeviceAsync(device);
UserDialogsService.HideLoading();
await ExecuteScanCommand();
}
catch (DeviceConnectionException e)
{
}
}
private async void SavePassExe()
{
if (OldPasswordEntry == UserPassword)
{
if (verifyPassword())
{
UserPassword = _passwordEntry;
await NavigationService.GoBack();
}
}
else
{
UserDialogsService.ShowAltert(TranslateService.ProvideValue("Message_OldPasswordDoesntMatch"), TranslateService.ProvideValue("Message_WrongPasswrdShort"));
}
}
private void OpenFileExe()
{
try
{
UserDialogsService.ShowLoading("Decrypting file...");
var bytes = default(byte[]);
var DecryptedData = default(byte[]);
using (var streamReader = new StreamReader(SelectedFileObject.FilePath))
{
using (var memstream = new MemoryStream())
{
streamReader.BaseStream.CopyTo(memstream);
bytes = memstream.ToArray();
}
}
switch (SelectedFileObject.FileEncryptionMethod)
{
case CryptMethod.AES:
DecryptedData = _AES.Decrypt(bytes, SelectedFileObject.FileDecryptionPassword);
break;
case CryptMethod.DES:
DecryptedData = _DES.Decrypt(bytes, SelectedFileObject.FileDecryptionPassword);
break;
case CryptMethod.TripleDES:
DecryptedData = _3DES.Decrypt(bytes, SelectedFileObject.FileDecryptionPassword);
break;
default:
break;
}
string decryptedFilePath = SaveFileContentToFile(DecryptedData, $"tmpDecrypted_{Path.GetFileName(SelectedFileObject.FilePath)}");
UserDialogsService.HideLoading();
DependencyService.Get <IDocumentOpener>().OpenFile(decryptedFilePath);
}
catch (Exception ex)
{
UserDialogsService.HideLoading();
//UserDialogsService.DisplayException(ex);
UserDialogsService.ShowAltert(TranslateService.ProvideValue("CantOpenFile"), "");
}
}
public void OpenFile(string path)
{
try
{
Android.Net.Uri uri;
string auth = "com.Linaq.LinaqStorage.Android.fileprovider";
string mimeType = Android.Webkit.MimeTypeMap.Singleton.GetMimeTypeFromExtension(Android.Webkit.MimeTypeMap.GetFileExtensionFromUrl(path.ToLower()));
if (mimeType == null)
{
mimeType = "*/*";
}
if (path.StartsWith("content://"))
{
uri = Android.Net.Uri.Parse(path);
}
else
{
var file = new Java.IO.File(Path.Combine(Android.App.Application.Context.FilesDir.Path, path));
uri = FileProvider.GetUriForFile(Android.App.Application.Context, auth, file);
}
//Intent.ActionView)
Intent intent = new Intent(Intent.ActionView);
intent.SetDataAndType(uri, mimeType);
intent.AddFlags(ActivityFlags.GrantReadUriPermission | ActivityFlags.GrantWriteUriPermission);
intent.AddFlags(ActivityFlags.NewTask | ActivityFlags.NoHistory);
//intent.SetAction(Intent.ActionGetContent);
// Trying to allow writing to the external app ...
var resInfoList = Android.App.Application.Context.PackageManager.QueryIntentActivities(intent, PackageInfoFlags.MatchDefaultOnly);
foreach (var resolveInfo in resInfoList)
{
var packageName = resolveInfo.ActivityInfo.PackageName;
Android.App.Application.Context.GrantUriPermission(packageName, uri, ActivityFlags.GrantWriteUriPermission | ActivityFlags.GrantPrefixUriPermission | ActivityFlags.GrantReadUriPermission);
}
Android.App.Application.Context.StartActivity(intent);
}
catch (Exception ex)
{
UserDialogsService.ShowAltert(TranslateService.ProvideValue("CantOpenFile"), "");
// Toast.MakeText(Android.App.Application.Context, TranslateService.ProvideValue("CantOpenFile"), ToastLength.Long).Show();
// Toast.MakeText(Android.App.Application.Context, $"Exception {ex.Message}, InnerException: {ex.InnerException}. StackTrace: {ex.StackTrace}", ToastLength.Long).Show();
}
}
private async Task GetBlutoothDevices()
{
var LocationPermission = await PermissionHelpers.RequestIfNeeded <Permissions.LocationAlways>();
if (LocationPermission == PermissionStatus.Granted)
{
DeviceList = new List <IDevice>();
await _adapterService.StartScanningForDevicesAsync();
_adapterService.DeviceDiscovered += (s, a) => DeviceList.Add(a.Device);
}
else
{
await UserDialogsService.AlertAsync("Location Permission is required");
}
}
private string SaveFileContentToFile(byte[] content, string filename)
{
try
{
string filePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), filename);
using (Stream file = File.OpenWrite(filePath))
{
file.Write(content, 0, content.Length);
}
return(filePath);
}
catch (Exception ex)
{
UserDialogsService.DisplayException(ex);
return(string.Empty);
}
}
async Task ExecuteScanCommand()
{
var LocationPermission = await PermissionHelpers.RequestIfNeeded <Permissions.LocationAlways>();
UserDialogsService.ShowLoading("Scan Bluetooth Device", MaskType.Gradient);
if (LocationPermission == PermissionStatus.Granted)
{
DeviceList = new List <IDevice>();
await _adapterService.StartScanningForDevicesAsync();
DeviceList = _adapterService.DiscoveredDevices.ToList();
}
else
{
await UserDialogsService.AlertAsync("Location Permission is required");
}
UserDialogsService.HideLoading();
}
private void ResetPassword()
{
try
{
JsonService.ResetList();
App.AppSettings.AddOrUpdateValue("UserPassword", string.Empty);
IEnumerable <string> files = Directory.EnumerateFiles(Constants.localAppDataFolder, "*");
foreach (string f in files)
{
File.Delete(f);
}
UserDialogs.Instance.Alert(TranslateService.ProvideValue("PasswordPage_PasswordResetSucessfully"), TranslateService.ProvideValue("PasswordPage_PasswordReset"), "Ok");
}
catch (Exception ex)
{
UserDialogsService.DisplayException(ex);
}
}
public App()
{
try
{
InitializeComponent();
Constants.InitConstatns();
InitCryptMethod();
CrossMultilingual.Current.CurrentCultureInfo = new CultureInfo(SelectedLanguage.ToLower());
AppResources.Culture = CrossMultilingual.Current.CurrentCultureInfo;
NavigationService.Configure("MainPage", typeof(MainPage));
NavigationService.Configure("DetailsPage", typeof(DetailsPage));
NavigationService.Configure("SettingsPage", typeof(SettingsPage));
NavigationService.Configure("LoginPage", typeof(LoginPage));
NavigationService.Configure("PasswordChangePage", typeof(PasswordChangePage));
NavigationService.Configure("PasswordSetPage", typeof(PasswordSetPage));
NavigationService.Configure("AboutPage", typeof(AboutPage));
NavigationService.Configure("HelpPage", typeof(HelpPage));
if (!IsUserLoggedIn)
{
if (!string.IsNullOrWhiteSpace(UserPassword))
{
MainPage = NavigationService.SetRootPage("LoginPage");
}
else
{
MainPage = NavigationService.SetRootPage("PasswordSetPage");
}
}
else
{
MainPage = NavigationService.SetRootPage("MainPage");
}
}
catch (Exception ex)
{
UserDialogsService.DisplayException(ex);
}
}
private async void SelectFile()
{
try
{
UserDialogsService.ShowLoading("Encrypting...");
FileData fileData = new FileData();
await Task.Run(async() =>
{
fileData = await CrossFilePicker.Current.PickFile();
if (fileData == null)
{
UserDialogsService.HideLoading();
return; // user canceled file picking
}
string fileName = fileData.FileName;
CreateNewFileObject(fileData.DataArray, fileData.FileName);
UpdateFilesList();
if (App.AppSettings.GetValueOrDefault("DeleteOriginalFile", false))
{
if (File.Exists(fileData.FilePath))
{
File.Delete(fileData.FilePath);
UserDialogs.Instance.Toast("Oryginalny plik został usuniety."); // zmienic na male okienko, dodac zmienna do settingsow czy usuwac czy nie
}
else
{
UserDialogs.Instance.Toast("Usuwanie oryginalnego pliku nie powiodlo sie.");
}
}
UserDialogsService.HideLoading();
});
}
catch (Exception ex)
{
UserDialogsService.DisplayException(ex);
}
}
private async void ResetPasswordExe()
{
try
{
bool ConfirmResult = await UserDialogs.Instance.ConfirmAsync(new ConfirmConfig
{
Title = TranslateService.ProvideValue("PasswordPage_PasswordReset"),
Message = TranslateService.ProvideValue("PasswordPage_PasswordResetInfoLoseData"),
OkText = "OK",
CancelText = TranslateService.ProvideValue("Cancel")
});
if (ConfirmResult)
{
ResetPassword();
await NavigationService.InsertNewRootPage("PasswordSetPage");
}
}
catch (Exception ex)
{
UserDialogsService.DisplayException(ex);
}
}
private bool verifyPassword()
{
string errorMessage = string.Empty;
if (string.IsNullOrWhiteSpace(_passwordEntry) || string.IsNullOrWhiteSpace(_confirmPasswordEntry) || string.IsNullOrWhiteSpace(_oldPasswordEntry))
{
errorMessage += TranslateService.ProvideValue("Message_FilleAllFields") + "\n";
}
if (_passwordEntry != _confirmPasswordEntry)
{
errorMessage += TranslateService.ProvideValue("Message_PasswordsDoesntMatch") + "\n";
}
if (_passwordEntry.Length < 8)
{
errorMessage += TranslateService.ProvideValue("Message_PasswordTooShort") + "\n";
}
if (!_passwordEntry.Any(char.IsSymbol))
{
errorMessage += TranslateService.ProvideValue("Message_PasswordOneSymbol") + "\n";
}
if (!_passwordEntry.Any(char.IsUpper))
{
errorMessage += TranslateService.ProvideValue("Message_PasswordOneBigLetter") + "\n";
}
if (!_passwordEntry.Any(char.IsNumber))
{
errorMessage += TranslateService.ProvideValue("Message_PasswordOneNumber") + "\n";
}
if (!string.IsNullOrWhiteSpace(errorMessage))
{
UserDialogsService.ShowAltert(errorMessage, TranslateService.ProvideValue("Message_WrongPasswrdShort"));
return(false);
}
return(true);
}
private void CreateNewFileObject(byte[] DataArray, string fdFileName)
{
try
{
string NewgGuid = Helpers.Helpers.CreateNewGuid;
byte[] EncryptedData = default(byte[]);
string psw = Helpers.Helpers.CreateNewGuidWithoutDash();
FileObject NewObject = new FileObject()
{
FileGuid = NewgGuid,
FileName = fdFileName,
FileEncryptionDate = DateTime.Now,
FileExtension = Path.GetExtension(fdFileName),
IsKeyEncrypted = false,
OriginalFileSize = DataArray.Length.ToString()
};
if (EncryptKeyWithRSA)
{
Tuple <string, string> Keys = _RSA.GenerateKey();
psw = _RSA.Encrypt(psw, Keys.Item1);
NewObject.IsKeyEncrypted = true;
NewObject.PublicRsa = Keys.Item1;
NewObject.PrivateRSA = Keys.Item2;
}
switch (SelectedEncryptionMethod)
{
case CryptMethod.AES:
NewObject.FileDecryptionPassword = psw;
NewObject.FileEncryptionMethod = SelectedEncryptionMethod;
EncryptedData = _AES.Encrypt(DataArray, NewObject.FileDecryptionPassword);
NewObject.FilePath = SaveFileContentToFile(EncryptedData, $"{NewgGuid}{Path.GetExtension(fdFileName)}");
NewObject.EncryptedFileSize = EncryptedData.Length.ToString();
break;
case CryptMethod.DES:
NewObject.FileDecryptionPassword = psw;
NewObject.FileEncryptionMethod = SelectedEncryptionMethod;
EncryptedData = _DES.Encrypt(DataArray, NewObject.FileDecryptionPassword);
NewObject.FilePath = SaveFileContentToFile(EncryptedData, $"{NewgGuid}{Path.GetExtension(fdFileName)}");
NewObject.EncryptedFileSize = EncryptedData.Length.ToString();
break;
case CryptMethod.TripleDES:
NewObject.FileDecryptionPassword = psw;
NewObject.FileEncryptionMethod = SelectedEncryptionMethod;
EncryptedData = _3DES.Encrypt(DataArray, NewObject.FileDecryptionPassword);
NewObject.FilePath = SaveFileContentToFile(EncryptedData, $"{NewgGuid}{Path.GetExtension(fdFileName)}");
NewObject.EncryptedFileSize = EncryptedData.Length.ToString();
break;
default:
NewObject.FileDecryptionPassword = psw;
NewObject.FileEncryptionMethod = SelectedEncryptionMethod;
EncryptedData = _AES.Encrypt(DataArray, NewObject.FileDecryptionPassword);
NewObject.FilePath = SaveFileContentToFile(EncryptedData, $"{NewgGuid}{Path.GetExtension(fdFileName)}");
NewObject.EncryptedFileSize = EncryptedData.Length.ToString();
break;
}
JsonService.AddFileToJsonList(NewObject);
}
catch (Exception ex)
{
UserDialogsService.DisplayException(ex);
}
}
