From 26f0ab66616cb6f9ca00b32927a6d5e6c19ffce8 Mon Sep 17 00:00:00 2001
From: Philipp Crocoll <philipp@crocoll.net>
Date: Wed, 2 Feb 2022 02:54:35 +0100
Subject: [PATCH] implement support for MEGA, closes #99

---
 .../Io/BuiltInFileStorage.cs                  |   2 +-
 src/Kp2aBusinessLogic/Io/MegaFileStorage.cs   | 506 ++++++++++++++++++
 .../Kp2aBusinessLogic.csproj                  |   7 +
 src/keepass2android/FileSelectHelper.cs       |  68 ++-
 .../drawable-mdpi/ic_storage_mega.png         | Bin 0 -> 1523 bytes
 .../drawable-xhdpi/ic_storage_mega.png        | Bin 0 -> 2318 bytes
 .../Resources/layout/megacredentials.xml      |  30 ++
 .../Resources/values/strings.xml              |   5 +-
 src/keepass2android/app/App.cs                |   1 +
 .../keepass2android-app.csproj                |  10 +
 10 files changed, 625 insertions(+), 4 deletions(-)
 create mode 100644 src/Kp2aBusinessLogic/Io/MegaFileStorage.cs
 create mode 100644 src/keepass2android/Resources/drawable-mdpi/ic_storage_mega.png
 create mode 100644 src/keepass2android/Resources/drawable-xhdpi/ic_storage_mega.png
 create mode 100644 src/keepass2android/Resources/layout/megacredentials.xml

diff --git a/src/Kp2aBusinessLogic/Io/BuiltInFileStorage.cs b/src/Kp2aBusinessLogic/Io/BuiltInFileStorage.cs
index 64df475e..aa8f428f 100644
--- a/src/Kp2aBusinessLogic/Io/BuiltInFileStorage.cs
+++ b/src/Kp2aBusinessLogic/Io/BuiltInFileStorage.cs
@@ -246,7 +246,7 @@ namespace keepass2android.Io
 			else
 			{
 				Intent intent = new Intent();
-				activity.IocToIntent(intent, new IOConnectionInfo() { Path = protocolId+"://"});
+				activity.IocToIntent(intent, new IOConnectionInfo() { Path = protocolId+"://", });
 				activity.OnImmediateResult(requestCode, (int) FileStorageResults.FileChooserPrepared, intent);
 			}
 		}
diff --git a/src/Kp2aBusinessLogic/Io/MegaFileStorage.cs b/src/Kp2aBusinessLogic/Io/MegaFileStorage.cs
new file mode 100644
index 00000000..fb8cb862
--- /dev/null
+++ b/src/Kp2aBusinessLogic/Io/MegaFileStorage.cs
@@ -0,0 +1,506 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Android.Content;
+using Android.OS;
+using Android.Preferences;
+using Android.Util;
+using CG.Web.MegaApiClient;
+using Group.Pals.Android.Lib.UI.Filechooser.Utils;
+using KeePassLib.Cryptography.Cipher;
+using KeePassLib.Serialization;
+using KeePassLib.Utility;
+
+namespace keepass2android.Io
+{
+    public class MegaFileStorage : IFileStorage
+    {
+        private readonly Context _appContext;
+        public const string ProtocolId = "mega";
+        private const string PreferenceKey = "KP2A-Mega-Accounts";
+
+        public MegaFileStorage(Context appContext)
+        {
+            _appContext = appContext;
+        }
+
+        //we don't want to store passwords in plain text, encrypt them with this key at least:
+        public static readonly byte[] EncryptionKey = new byte[] { 86,239,128,218,160,22,245,114,193,92,151,10,134,104,121,170,
+            183,110,60,38,179,181,24,206,169,43,125,193,142,156,47,45};
+
+        public class AccountSettings
+        {
+            public Dictionary<string, string> PasswordByUsername { get; set; } = new Dictionary<string, string>();
+
+            public static byte[] exclusiveOR(byte[] arr1, byte[] arr2)
+            {
+                byte[] result = new byte[arr1.Length];
+
+                for (int i = 0; i < arr1.Length; ++i)
+                    result[i] = (byte)(arr1[i] ^ arr2[i % arr2.Length]);
+
+                return result;
+            }
+
+            static string Encrypt(string s)
+            {
+                var plainTextBytes = exclusiveOR(System.Text.Encoding.UTF8.GetBytes(s), EncryptionKey);
+                return System.Convert.ToBase64String(plainTextBytes);
+
+            }
+
+            static string Decrypt(string s)
+            {
+                var base64EncodedBytes = System.Convert.FromBase64String(s);
+                return System.Text.Encoding.UTF8.GetString(exclusiveOR(base64EncodedBytes, EncryptionKey));
+
+            }
+
+            public string Serialize()
+            {
+                Dictionary<string, string> encryptedPasswordByUsername = PasswordByUsername
+                    .Select(kvp => new KeyValuePair<string, string>(kvp.Key, Encrypt(kvp.Value)))
+                    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+                return Newtonsoft.Json.JsonConvert.SerializeObject(encryptedPasswordByUsername);
+            }
+
+            public void Deserialize(string data)
+            {
+                if (string.IsNullOrEmpty(data))
+                {
+                    PasswordByUsername = new Dictionary<string, string>();
+                    return;
+                }
+                Dictionary<string, string> encryptedPasswordByUsername =
+                    Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(data);
+                PasswordByUsername = encryptedPasswordByUsername
+                    .Select(kvp => new KeyValuePair<string, string>(kvp.Key, Decrypt(kvp.Value)))
+                    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+            }
+        }
+
+        public IEnumerable<string> SupportedProtocols
+        {
+            get { yield return ProtocolId; }
+        }
+
+        public bool UserShouldBackup
+        {
+            get { return false; }
+        }
+
+
+        class MegaFileStorageWriteTransaction : IWriteTransaction
+        {
+            public bool UseFileTransaction { get; }
+            private readonly string _path;
+            private readonly MegaFileStorage _filestorage;
+            private MemoryStream _memoryStream;
+
+            public MegaFileStorageWriteTransaction(string path, MegaFileStorage filestorage, bool useFileTransaction)
+            {
+                UseFileTransaction = useFileTransaction;
+                _path = path;
+                _filestorage = filestorage;
+            }
+
+            public void Dispose()
+            {
+                _memoryStream.Dispose();
+            }
+
+            public Stream OpenFile()
+            {
+                _memoryStream = new MemoryStream();
+                return _memoryStream;
+            }
+
+            public void CommitWrite()
+            {
+                _filestorage.UploadFile(_path, new MemoryStream(_memoryStream.ToArray()), UseFileTransaction);
+
+            }
+        }
+
+        private void UploadFile(string path, MemoryStream memoryStream, bool useTransaction)
+        {
+            var accountData = GetAccountData(path);
+
+            if (accountData.TryGetNode(path, out var node))
+            {
+                if (useTransaction)
+                {
+                    string temporaryName = node.Name + "." + new Guid().ToString() + ".tmp";
+                    var newNode = accountData.Client.Upload(memoryStream, temporaryName, accountData.GetParentNode(node));
+                    accountData.Client.Delete(node);
+                    newNode = accountData.Client.Rename(newNode, node.Name);
+                    accountData._nodes.Remove(node);
+                    accountData._nodes.Add(newNode);
+                }
+                else
+                {
+                    var newNode = accountData.Client.Upload(memoryStream, node.Name, accountData.GetParentNode(node));
+                    //we now have two nodes with the same name. Delete the old one:
+                    accountData.Client.Delete(node);
+                    accountData._nodes.Remove(node);
+                    accountData._nodes.Add(newNode);
+
+                }
+            }
+            else
+            {
+                //file did not exist yet
+                string parentPath = GetParentPath(new IOConnectionInfo() { Path = path }).Path;
+                string name = path.Substring(parentPath.Length + 1);
+                var newNode = accountData.Client.Upload(memoryStream, name, accountData.GetNode(parentPath));
+                accountData._nodes.Add(newNode);
+            }
+
+        }
+
+        public void StartSelectFile(IFileStorageSetupInitiatorActivity activity, bool isForSave, int requestCode,
+            string protocolId)
+        {
+            activity.PerformManualFileSelect(isForSave, requestCode, protocolId);
+        }
+
+        public void OnCreate(IFileStorageSetupActivity activity, Bundle savedInstanceState)
+        {
+        }
+
+        public void OnResume(IFileStorageSetupActivity activity)
+        {
+        }
+
+        public void OnStart(IFileStorageSetupActivity activity)
+        {
+        }
+
+        public void OnActivityResult(IFileStorageSetupActivity activity, int requestCode, int resultCode, Intent data)
+        {
+        }
+
+        public IWriteTransaction OpenWriteTransaction(IOConnectionInfo ioc, bool useFileTransaction)
+        {
+            return new MegaFileStorageWriteTransaction(ioc.Path, this, useFileTransaction);
+        }
+
+        public string GetFilenameWithoutPathAndExt(IOConnectionInfo ioc)
+        {
+            return UrlUtil.StripExtension(
+                UrlUtil.GetFileName(ioc.Path));
+        }
+
+        public string GetFileExtension(IOConnectionInfo ioc)
+        {
+            return UrlUtil.GetExtension(ioc.Path);
+        }
+
+        public string CreateFilePath(string parent, string newFilename)
+        {
+            if (!parent.EndsWith("/"))
+                parent += "/";
+            return parent + newFilename;
+        }
+
+        public bool IsReadOnly(IOConnectionInfo ioc, OptionalOut<UiStringKey> reason = null)
+        {
+            return false;
+        }
+
+        public bool IsPermanentLocation(IOConnectionInfo ioc)
+        {
+            return true;
+        }
+
+        public IOConnectionInfo GetFilePath(IOConnectionInfo folderPath, string filename)
+        {
+            IOConnectionInfo res = folderPath.CloneDeep();
+            if (!res.Path.EndsWith("/"))
+                res.Path += "/";
+            res.Path += filename;
+            return res;
+        }
+
+        public IOConnectionInfo GetParentPath(IOConnectionInfo ioc)
+        {
+            return IoUtil.GetParentPath(ioc);
+        }
+
+        public string GetDisplayName(IOConnectionInfo ioc)
+        {
+            return ioc.GetDisplayName();
+        }
+
+        public void PrepareFileUsage(Context ctx, IOConnectionInfo ioc)
+        {
+            //nothing to do
+        }
+
+        public void PrepareFileUsage(IFileStorageSetupInitiatorActivity activity, IOConnectionInfo ioc, int requestCode,
+            bool alwaysReturnSuccess)
+        {
+            Intent intent = new Intent();
+            activity.IocToIntent(intent, ioc);
+            activity.OnImmediateResult(requestCode, (int)FileStorageResults.FileUsagePrepared, intent);
+        }
+
+        public string IocToPath(IOConnectionInfo ioc)
+        {
+            return ioc.Path;
+        }
+
+        public bool RequiresSetup(IOConnectionInfo ioConnection)
+        {
+            return false;
+        }
+
+        public FileDescription GetFileDescription(IOConnectionInfo ioc)
+        {
+            var accountData = GetAccountData(ioc);
+            return MakeFileDescription(accountData, accountData.GetNode(ioc));
+        }
+
+        class AccountData
+        {
+            public string Account { get; set; }
+            public IMegaApiClient Client { get; set; }
+
+            public void RefreshMetadata()
+            {
+                //make sure we refresh meta data after one minute:
+                if (DateTime.Now.Subtract(_nodesLoadingTime).TotalMinutes > 1.0)
+                {
+                    _nodes.Clear();
+                    EnsureMetadataLoaded();
+                }
+            }
+
+            public List<INode> _nodes = new List<INode>();
+            private DateTime _nodesLoadingTime;
+            private INode _rootNode;
+
+            public INode GetNode(IOConnectionInfo ioc)
+            {
+                return GetNode(ioc.Path);
+            }
+
+            public bool TryGetNode(string path, out INode node)
+            {
+                try
+                {
+                    node = GetNode(path);
+                    return true;
+                }
+                catch (Exception e)
+                {
+                    node = null;
+                    return false;
+                }
+            }
+
+            public INode GetNode(string path)
+            {
+                EnsureMetadataLoaded();
+                if (!path.StartsWith(ProtocolId + "://"))
+                    throw new Exception("Invalid Mega URL: " + path);
+                path = path.Substring(ProtocolId.Length + 3);
+                var parts = path.Split('/');
+                if (parts.Length < 1 || parts[0] == "")
+                    throw new Exception("Invalid Mega URL: " + path);
+
+                INode node = _rootNode;
+                for (int i = 1; i < parts.Length; i++)
+                {
+                    if (parts[i] == "")
+                        continue;
+                    var matchingChildren = _nodes.Where(n => n.ParentId == node.Id && n.Name == parts[i]).ToList();
+                    if (matchingChildren.Count == 0)
+                        throw new FileNotFoundException("Did not find " + path);
+                    if (matchingChildren.Count > 1)
+                        throw new Java.IO.FileNotFoundException(
+                            $"Found more than one child with name {parts[i]} while trying to get node for {path}");
+                    node = matchingChildren.Single();
+                }
+
+                return node;
+
+            }
+
+            private void EnsureMetadataLoaded()
+            {
+                if (_nodes.Any() == false)
+                {
+                    _nodes = Client.GetNodes().ToList();
+
+                    _rootNode = _nodes.Single(n => n.Type == NodeType.Root);
+                    _nodesLoadingTime = DateTime.Now;
+                }
+            }
+
+            public INode GetParentNode(INode node)
+            {
+                return _nodes.Single(n => n.Id == node.ParentId);
+            }
+
+            internal void InvalidateMetaData()
+            {
+                _nodes.Clear();
+            }
+
+            public IEnumerable<INode> GetChildNodes(INode node)
+            {
+                EnsureMetadataLoaded();
+                return _nodes.Where(n => n.ParentId == node.Id);
+            }
+
+            public string GetPath(INode node)
+            {
+                if (node.Type == NodeType.Root)
+                    return ProtocolId + "://" + this.Account;
+                var parent = _nodes.Single(n => n.Id == node.ParentId);
+                return GetPath(parent) + "/" + node.Name;
+            }
+        }
+
+
+        readonly Dictionary<string /*account*/, AccountData> _allAccountData = new Dictionary<string, AccountData>();
+
+        public string GetAccount(IOConnectionInfo ioc)
+        {
+            return GetAccount(ioc.Path);
+        }
+
+        public static string GetAccount(string path)
+        {
+            if (!path.StartsWith(ProtocolId + "://"))
+                throw new Exception("Invalid Mega URL: " + path);
+            path = path.Substring(ProtocolId.Length + 3);
+            var parts = path.Split('/');
+            if (parts.Length < 1 || parts[0] == "")
+                throw new Exception("Invalid Mega URL: " + path);
+            return parts[0];
+
+
+        }
+
+        private AccountData GetAccountData(IOConnectionInfo ioc)
+        {
+            return GetAccountData(ioc.Path);
+        }
+
+        public static AccountSettings GetAccountSettings(Context ctx)
+        {
+            string accountSettingsString = PreferenceManager.GetDefaultSharedPreferences(ctx).GetString(PreferenceKey, null);
+            AccountSettings settings = new AccountSettings();
+            settings.Deserialize(accountSettingsString);
+            return settings;
+        }
+
+        public static void UpdateAccountSettings(AccountSettings settings, Context ctx)
+        {
+            PreferenceManager.GetDefaultSharedPreferences(ctx).Edit().PutString(PreferenceKey, settings.Serialize())
+                .Commit();
+        }
+
+        private AccountData GetAccountData(string path)
+        {
+            string account = GetAccount(path);
+            if (_allAccountData.TryGetValue(account, out var accountData))
+            {
+                return accountData;
+            }
+
+            AccountData newAccountData = new AccountData()
+            {
+                Account = account,
+                Client = new MegaApiClient()
+            };
+
+            var settings = GetAccountSettings(_appContext);
+            if (!settings.PasswordByUsername.TryGetValue(account, out string password))
+            {
+                throw new Exception("No account configured with username = " + account);
+            }
+
+            try
+            {
+                newAccountData.Client.Login(account, password);
+            }
+            catch (CG.Web.MegaApiClient.ApiException e)
+            {
+                if (e.ApiResultCode == CG.Web.MegaApiClient.ApiResultCode.ResourceNotExists)
+                {
+                    throw new Exception("Failed to login to MEGA account. Please check username and password!");
+                }
+                    
+            }
+            
+
+            _allAccountData[account] = newAccountData;
+            return newAccountData;
+
+        }
+
+        public IEnumerable<FileDescription> ListContents(IOConnectionInfo ioc)
+        {
+            AccountData accountData = GetAccountData(ioc);
+            accountData.RefreshMetadata();
+            return accountData.GetChildNodes(accountData.GetNode(ioc)).Select(n => MakeFileDescription(accountData, n));
+
+
+        }
+
+        private FileDescription MakeFileDescription(AccountData account, INode n)
+        {
+            return new FileDescription()
+            {
+                CanRead = true,
+                CanWrite = true,
+                DisplayName = n.Name ?? (n.Type == NodeType.Root ? "root" : ""),
+                IsDirectory = n.Type != NodeType.File,
+                LastModified = n.ModificationDate ?? n.CreationDate ?? DateTime.MinValue,
+                Path = account.GetPath(n),
+                SizeInBytes = n.Size
+            };
+        }
+
+        public void CreateDirectory(IOConnectionInfo ioc, string newDirName)
+        {
+            var accountData = GetAccountData(ioc);
+            var newNode = accountData.Client.CreateFolder(newDirName, accountData.GetNode(ioc));
+            accountData._nodes.Add(newNode);
+        }
+
+        public bool RequiresCredentials(IOConnectionInfo ioc)
+        {
+            return false;
+        }
+
+
+        public Stream OpenFileForRead(IOConnectionInfo ioc)
+        {
+            var accountData = GetAccountData(ioc);
+            return accountData.Client.Download(accountData.GetNode(ioc));
+        }
+
+        public string GetCurrentFileVersionFast(IOConnectionInfo ioc)
+        {
+            return null;
+        }
+
+        public bool CheckForFileChangeFast(IOConnectionInfo ioc, string previousFileVersion)
+        {
+            return false;
+        }
+
+        public void Delete(IOConnectionInfo ioc)
+        {
+            var accountData = GetAccountData(ioc);
+            accountData.Client.Delete(accountData.GetNode(ioc));
+        }
+
+        
+    }
+}
\ No newline at end of file
diff --git a/src/Kp2aBusinessLogic/Kp2aBusinessLogic.csproj b/src/Kp2aBusinessLogic/Kp2aBusinessLogic.csproj
index 714295a2..287de7c7 100644
--- a/src/Kp2aBusinessLogic/Kp2aBusinessLogic.csproj
+++ b/src/Kp2aBusinessLogic/Kp2aBusinessLogic.csproj
@@ -87,6 +87,7 @@
     <Compile Include="Io\IFileStorage.cs" />
     <Compile Include="Io\IoUtil.cs" />
     <Compile Include="Io\JavaFileStorage.cs" />
+    <Compile Include="Io\MegaFileStorage.cs" />
     <Compile Include="Io\NetFtpFileStorage.cs" />
     <Compile Include="Io\OfflineSwitchableFileStorage.cs" />
     <Compile Include="Io\OneDrive2FileStorage.cs" />
@@ -165,6 +166,9 @@
     <PackageReference Include="FluentFTP">
       <Version>31.3.1</Version>
     </PackageReference>
+    <PackageReference Include="MegaApiClient">
+      <Version>1.10.2</Version>
+    </PackageReference>
     <PackageReference Include="Microsoft.Graph">
       <Version>1.21.0</Version>
     </PackageReference>
@@ -276,6 +280,9 @@
     <PackageReference Include="Xamarin.Android.Support.ViewPager">
       <Version>28.0.0.3</Version>
     </PackageReference>
+    <PackageReference Include="Xamarin.AndroidX.Preference">
+      <Version>1.1.1.11</Version>
+    </PackageReference>
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/src/keepass2android/FileSelectHelper.cs b/src/keepass2android/FileSelectHelper.cs
index 11064101..1357c771 100644
--- a/src/keepass2android/FileSelectHelper.cs
+++ b/src/keepass2android/FileSelectHelper.cs
@@ -229,6 +229,67 @@ namespace keepass2android
 		}
 
 
+		private void ShowMegaDialog(Activity activity, Util.FileSelectedHandler onStartBrowse, Action onCancel, string defaultPath)
+		{
+#if !NoNet
+            var settings = MegaFileStorage.GetAccountSettings(activity);
+			AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+			View dlgContents = activity.LayoutInflater.Inflate(Resource.Layout.megacredentials, null);
+			if (!defaultPath.EndsWith(_schemeSeparator))
+            {
+                string user = "";
+                string password = "";
+                if (!defaultPath.EndsWith(_schemeSeparator))
+				{
+					 user = MegaFileStorage.GetAccount(defaultPath);
+                     if (!settings.PasswordByUsername.TryGetValue(user, out password))
+                         password = "";
+                     dlgContents.FindViewById<EditText>(Resource.Id.mega_user).Enabled = false;
+
+                }
+				dlgContents.FindViewById<EditText>(Resource.Id.mega_user).Text = user;
+				dlgContents.FindViewById<EditText>(Resource.Id.mega_password).Text = password;
+
+			}
+
+            var userView = ((AutoCompleteTextView)dlgContents.FindViewById(Resource.Id.mega_user));
+            userView.Adapter = new ArrayAdapter(activity, Android.Resource.Layout.SimpleListItem1, Android.Resource.Id.Text1, settings.PasswordByUsername.Keys.ToArray());
+
+            userView.TextChanged += (sender, args) =>
+            {
+                if (userView.Text != null && settings.PasswordByUsername.TryGetValue(userView.Text, out string pwd))
+                {
+                    dlgContents.FindViewById<EditText>(Resource.Id.mega_password).Text = pwd;
+				}
+            };
+            builder.SetCancelable(false);
+			builder.SetView(dlgContents);
+			builder.SetPositiveButton(Android.Resource.String.Ok,
+									  (sender, args) =>
+									  {
+										  string user = dlgContents.FindViewById<EditText>(Resource.Id.mega_user).Text;
+										  string password = dlgContents.FindViewById<EditText>(Resource.Id.mega_password).Text;
+										  //store the credentials in the mega credentials store:
+                                          
+
+                                          settings.PasswordByUsername[user] = password;
+
+                                          MegaFileStorage.UpdateAccountSettings(settings, activity);
+
+                                          onStartBrowse(MegaFileStorage.ProtocolId + "://" + user);
+                                      });
+			EventHandler<DialogClickEventArgs> evtH = new EventHandler<DialogClickEventArgs>((sender, e) => onCancel());
+
+			builder.SetNegativeButton(Android.Resource.String.Cancel, evtH);
+			builder.SetTitle(activity.GetString(Resource.String.enter_mega_login_title));
+			Dialog dialog = builder.Create();
+
+			dialog.Show();
+#endif
+		}
+
+
+
 		public void PerformManualFileSelect(string defaultPath)
 		{
 			if (defaultPath.StartsWith("sftp://"))
@@ -241,7 +302,9 @@ namespace keepass2android
 				ShowOwncloudDialog(_activity, ReturnFileOrStartFileChooser, ReturnCancel, defaultPath, "owncloud");
 			else if (defaultPath.StartsWith("nextcloud://"))
 			    ShowOwncloudDialog(_activity, ReturnFileOrStartFileChooser, ReturnCancel, defaultPath, "nextcloud");
-            else
+            else if (defaultPath.StartsWith("mega://"))
+                ShowMegaDialog(_activity, ReturnFileOrStartFileChooser, ReturnCancel, defaultPath);
+			else
 			{
 				Func<string, Dialog, bool> onOpen = OnOpenButton;
 				Util.ShowFilenameDialog(_activity,
@@ -472,7 +535,8 @@ namespace keepass2android
 	    {
 	        return ioc.Path.StartsWith("http")
 	               || ioc.Path.StartsWith("ftp")
-	               || ioc.Path.StartsWith("sftp");
+	               || ioc.Path.StartsWith("sftp")
+                   || ioc.Path.StartsWith("mega");
 
 	    }
 
diff --git a/src/keepass2android/Resources/drawable-mdpi/ic_storage_mega.png b/src/keepass2android/Resources/drawable-mdpi/ic_storage_mega.png
new file mode 100644
index 0000000000000000000000000000000000000000..4b90753bac2676693c0dfd3b27dc0e5e4d990877
GIT binary patch
literal 1523
zcmV<P1q}L$P)<h;3K|Lk000e1NJLTq001Na001Ni1^@s6;Q*MJ0004nX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmP!xqv(@I4u4t5af5U@H~5EXHhDi*;)X)CnqVDi#GXws0R
zxHt-~1qXi?s}3&Cx;nTDg5VE`qmz@Oi<Ed@QfLw5g$Ez!-E+C`JV0nxnQ8_m09CV$
zbRsV1@~dL-6+T1|Knx=iGxcO<F$>T7x~FccyBMG4-S=npD+QAQK9P8i>4rtTK|Hf*
z>74h8!>lYR#OK801}#YZ$aUG}H_j!81wJ!uWYhD+VPdh=#c~(3vY`@B6Gs(QqxnM4
zWrgz=XSG^q?LGMmLj`Rm!*x0lB(Q`eQV=1djtZ)<D6a}MQcR@jKJMWkcKj)F$>gel
zkz)ZhsE`~#_#gbv)+|m<x|2e2py$Q5KSqJzF3@V&_V=-Ew@v{6GjOGK{Iw=9`$>AE
zqeYK^fo<U8x}(W^z~v4w^rTCM<Vb!xLa_+EpV2qvfx%m#Z_UlEeUH-zAWK;--v9@P
zz*vc9uY0_^w>!6gd)oQ^0I7v?y%Avrw*UYD24YJ`L;!ODa{zPLir4P|000SaNLh0L
z04^f{04^f|c%?sf00007bV*G`2j&4E3la{h%8qjY000?uMObu0Z*6U5Zgc=ca%Ew3
zWn>_CX>@2HM@dakSAh-}000BZNkl<ZSi`-TU5Hgx6vu!2+^gf59}U%@jT9t-IYLkt
z?ZB7Bmm+#_6e^0e$SKNb-@qpcdXqYfK!Vc54=Cw_kePXihNi+|TM$8nMnnpJCZ=L}
z$2-j2?St#+VVZm9oI7)8!F{>xbI$Ml_d09+*ESRg=Uf}G40r^12<Qg7fcZcGE&<1Z
z-vAGM4g4h{BYB@;a)K-XdVr0<eLx!!O>$WsxT0Vm0(~M<of439ZWi!3@TRI!qPZ9a
zeg?Jz--yU)qlKjmm|KB&fwzF$b10G(5wJv6UTCd7<h`%uR>(QG6xavYyxUqJ>cCgP
zMiDtZDUfsSF5nB`URoCc_#Rj<B4-+InQqgkzyq{43~&dq%v#&;y&w4>kS4GIPqbj0
z8bK`uu-1O(y$_5_)W?8lX9y-O$ZMLbHxzQt&DSLEV&-EuaHqBQ6Yu?4qR?8cGmXBA
zVf~FYS%ZePNQMS$R%!LeXge6xKPQSWjWMqP^$^0Nz&7BfoG|Bs&BmA?fY~90kAeFe
zto;mlDgy2XR%YDvR0!c%9LGn2_kmY|%Q;{!02_e)aU35DAshwHW~^TWbVe#wTb|by
zkulA+%|LY$nCE~25vk`?a~`lN(ypDmEhyApRjQhyOc5A>GVovotSFkLDX8&ET~tTV
zUl1mV?xg7z@kFH*)E=!PRfXALjOj~YlC=e*D*_f2G-z))=h_n}W6W+~lNQy!IF1vT
zg~03D0rEyiQA-g4y};Yfxj6uF9FGAXrE^9N-43m9MV?_IwVg%F{U+d@1WH7Lh=g%4
zJxzG13lVU#iR3FQ)ODp&FdqQxnlyAL%fR7gzBGmE1%h*K3ouJz)=$A*9xelinv^$z
zdPygdcHrSDz>ESvm4P9krZ=QXs5R5j^)CYlBj9)7myCs-K&Nx=Hg$PLz;6Z?>$Qu3
zTQb%T0cVUR;|tn2OAYKtO|3%&%qi%d6Wd`j=D87|M@0IgRO>&IQG42fxdmYoo0?qP
zo{?W(EzmVZy!SP0?K$<+C1y6Nz>6aC=Xg(j0N9`5>RJ(X;632rgmYP?Qt1pK49vh7
zl;qbSuueoSrSs!@#BqEUct(q5t6_cwo=?L}INN*g|FPB%sc~D}qEY%=;As&#k?XL*
zdw<Sa+pj?POk<+gfSo|Ei2PmX^uv4qpS5-X_(OYL#}wPbufWT|_N;TFNw=d?shAK#
z2k@lY({3H^OpZLM>ABD@;ByiAcUn%+QebU*DzaL~-{m^(CR58Wa3Xc2HwYXNky_s8
ZTm>|GM13NK4w3)>002ovPDHLkV1m4{uXO+b

literal 0
HcmV?d00001

diff --git a/src/keepass2android/Resources/drawable-xhdpi/ic_storage_mega.png b/src/keepass2android/Resources/drawable-xhdpi/ic_storage_mega.png
new file mode 100644
index 0000000000000000000000000000000000000000..9922be9d4f7871d30e8c1ad050329384d724ea09
GIT binary patch
literal 2318
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

literal 0
HcmV?d00001

diff --git a/src/keepass2android/Resources/layout/megacredentials.xml b/src/keepass2android/Resources/layout/megacredentials.xml
new file mode 100644
index 00000000..da669351
--- /dev/null
+++ b/src/keepass2android/Resources/layout/megacredentials.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:layout_margin="12dip"
+    >
+  <AutoCompleteTextView
+    android:id="@+id/mega_user"
+    android:hint="@string/hint_username"
+  android:singleLine="true"
+    android:inputType="textWebEmailAddress"
+  
+  android:dropDownWidth="match_parent"
+  android:layout_width="fill_parent"
+  android:layout_height="wrap_content"
+  />
+ 
+  <EditText
+            android:id="@+id/mega_password"
+            android:layout_width="fill_parent"
+            android:layout_height="wrap_content"
+            android:inputType="textPassword"
+            android:text=""
+            android:singleLine="true"
+            android:hint="@string/hint_pass" 
+            android:importantForAccessibility="no"/>
+
+
+</LinearLayout>
\ No newline at end of file
diff --git a/src/keepass2android/Resources/values/strings.xml b/src/keepass2android/Resources/values/strings.xml
index f7706208..7290d1ed 100644
--- a/src/keepass2android/Resources/values/strings.xml
+++ b/src/keepass2android/Resources/values/strings.xml
@@ -591,6 +591,7 @@
 
   <string name="enter_ftp_login_title">Enter FTP login data:</string>
 
+  <string name="enter_mega_login_title">Enter your MEGA account login data:</string>
 
   <string name="select_storage_type">Select the storage type:</string>
 	
@@ -615,7 +616,9 @@
   <string name="filestoragename_onedrive2_myfiles">My files</string>
   <string name="filestoragename_onedrive2_appfolder">Keepass2Android App folder</string>
   <string name="filestoragename_sftp">SFTP (SSH File Transfer)</string>
-	<string name="filestoragename_content">System file picker</string>
+  <string name="filestoragename_mega">MEGA</string>
+  <string name="filestoragehelp_mega">Please note: Keepass2Android must download the list of all files in your Mega account to work properly. For this reason, accessing accounts with many files might be slow.</string>
+  <string name="filestoragename_content">System file picker</string>
 
 	<string name="filestorage_setup_title">File access initialization</string>
 
diff --git a/src/keepass2android/app/App.cs b/src/keepass2android/app/App.cs
index 2505ebbc..56ef1767 100644
--- a/src/keepass2android/app/App.cs
+++ b/src/keepass2android/app/App.cs
@@ -733,6 +733,7 @@ namespace keepass2android
 							new NetFtpFileStorage(LocaleManager.LocalizedAppContext, this),
 							new WebDavFileStorage(this),
 							new PCloudFileStorage(LocaleManager.LocalizedAppContext, this),
+							new MegaFileStorage(App.Context),
 							//new LegacyWebDavStorage(this),
                             //new LegacyFtpStorage(this),
 #endif
diff --git a/src/keepass2android/keepass2android-app.csproj b/src/keepass2android/keepass2android-app.csproj
index 670723d7..3eadcb8c 100644
--- a/src/keepass2android/keepass2android-app.csproj
+++ b/src/keepass2android/keepass2android-app.csproj
@@ -467,6 +467,7 @@
     <AndroidResource Include="Resources\drawable-mdpi\ic_storage_androidsend.png" />
     <AndroidResource Include="Resources\drawable-mdpi\ic_storage_content.png" />
     <AndroidResource Include="Resources\drawable-mdpi\ic_storage_dropbox.png" />
+    <AndroidResource Include="Resources\drawable-mdpi\ic_storage_mega.png" />
     <AndroidResource Include="Resources\drawable-mdpi\ic_storage_pcloud.png" />
     <AndroidResource Include="Resources\drawable-mdpi\ic_storage_dropboxKP2A.png" />
     <AndroidResource Include="Resources\drawable-mdpi\ic_storage_file.png" />
@@ -1078,6 +1079,9 @@
   <ItemGroup>
     <AndroidResource Include="Resources\drawable-xhdpi\ic_storage_dropbox.png" />
   </ItemGroup>
+  <ItemGroup>
+    <AndroidResource Include="Resources\drawable-xhdpi\ic_storage_mega.png" />
+  </ItemGroup>
   <ItemGroup>
     <AndroidResource Include="Resources\drawable-xhdpi\ic_storage_dropboxKP2A.png" />
   </ItemGroup>
@@ -1936,6 +1940,12 @@
       <Name>ZlibAndroid</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <AndroidResource Include="Resources\layout\megacredentials.xml">
+      <Generator>MSBuild:UpdateGeneratedFiles</Generator>
+      <SubType>Designer</SubType>
+    </AndroidResource>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
     Other similar extension points exist, see Microsoft.Common.targets.