public Task <bool> SetPublicAndPrivateKey(LocalBox localBox, string passPhrase)
{
return(Task.Run(() => {
try {
byte[] publicKey;
byte[] privateKey;
CryptoHelper.GenerateKeyPair(localBox.User, passPhrase, out publicKey, out privateKey);
var explorer = new RemoteExplorer(localBox);
var result = explorer.UpdateUser(new UserPost()
{
PublicKey = Convert.ToBase64String(publicKey),
PrivateKey = Convert.ToBase64String(privateKey)
});
if (result)
{
localBox.PublicKey = publicKey;
localBox.PrivateKey = privateKey;
localBox.PassPhrase = passPhrase;
DataLayer.Instance.AddOrUpdateLocalBox(localBox);
}
return result;
} catch (Exception ex) {
Insights.Report(ex);
return false;
}
}));
}
public async override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
var remoteExplorer = new RemoteExplorer();
try {
var remoteSites = await remoteExplorer.GetSites();
foreach (LocalBox box in DataLayer.Instance.GetLocalBoxesSync())
{
for (int i = 0; i < remoteSites.Count; i++)
{
if (box.BaseUrl == remoteSites[i].Url)
{
remoteSites.RemoveAt(i);
break;
}
}
}
foreach (Site site in remoteSites)
{
sites.Add(site);
}
sitesAdapter.NotifyDataSetChanged();
} catch (Exception ex) {
Insights.Report(ex);
}
}
public Task <bool> UpdateSettingsSharedFolder(Share share, List <Identity> usersToShareWith)
{
return(Task.Run(() => {
LocalBox box = DataLayer.Instance.GetSelectedOrDefaultBox();
var explorer = new RemoteExplorer(box);
List <Identity> inBoth = (from local in share.Identities
join remote in usersToShareWith
on local.Id equals remote.Id
select local).ToList();
var toAdd = usersToShareWith.Where(e => inBoth.All(f => f.Id != e.Id)).ToList();
var toRemove = share.Identities.Where(e => inBoth.All(f => f.Id != e.Id)).ToList();
var messages = AddKeys(share.Item.Path, usersToShareWith, toAdd);
RemoveKeys(share.Item.Path, toRemove);
var result = explorer.UpdateSettingsSharedFolder(share.Id, usersToShareWith);
foreach (var message in messages)
{
var r = explorer.AddAesKey(share.Item.Path, message);
}
return result;
}));
}
public Task <bool> UploadFile(string destination, string file)
{
return(Task.Run(() => {
try {
var remoteExplorer = new RemoteExplorer();
if (destination.Count(e => e == '/') > 1)
{
int index = destination.IndexOf('/', destination.IndexOf('/') + 1);
var rootFolder = destination.Substring(0, index);
var folder = GetFolder(rootFolder).Result;
if (folder.HasCryptoKeys)
{
Rijndael rijndael = Rijndael.Create();
rijndael.Key = folder.Key;
rijndael.IV = folder.IV;
using (var stream = new CryptoStream(File.OpenRead(file), rijndael.CreateEncryptor(), CryptoStreamMode.Read)) {
return remoteExplorer.UploadFile(destination, stream);
}
}
}
using (var stream = File.OpenRead(file)) {
return remoteExplorer.UploadFile(destination, stream);
}
} catch (Exception ex) {
Insights.Report(ex);
return false;
}
}));
}
public Task <bool> Authenticate(LocalBox localBox)
{
return(Task.Run(() => {
//bool result = false;
try {
var explorer = new RemoteExplorer(localBox);
//result = explorer.Authorize (password);
//if (result) {
DataLayer.Instance.AddOrUpdateLocalBox(localBox);
SetKeys(localBox);
//} else {
//Login failure so delete local box
// DataLayer.Instance.DeleteLocalBox (localBox.Id);
//}
return true;
} catch (Exception ex) {
Insights.Report(ex);
DataLayer.Instance.DeleteLocalBox(localBox.Id);
return false;
}
}));
}
public Task <PublicUrl> CreatePublicFileShare(string filePath, DateTime expirationDateOfShare)
{
return(Task.Run(() => {
var remoteExplorer = new RemoteExplorer();
return remoteExplorer.CreatePublicFileShare(filePath, expirationDateOfShare);
}));
}
public Task <bool> DeleteFileOrFolder(string fileOrFolderPath)
{
return(Task.Run(() => {
var remoteExplorer = new RemoteExplorer();
DeleteLocalFileOrFolder(fileOrFolderPath);
return remoteExplorer.DeleteFile(fileOrFolderPath);
}));
}
public Task <List <Identity> > GetLocalboxUsers()
{
return(Task.Run(() => {
var currentBox = GetSelectedOrDefaultBox();
var remoteExplorer = new RemoteExplorer();
var users = remoteExplorer.GetLocalBoxUsers().Result.Where(e => e.Username != currentBox.User).ToList();
return users;
}));
}
private void SetKeys(LocalBox localBox)
{
var explorer = new RemoteExplorer(localBox);
var user = explorer.GetUser();
if (user != null && !(string.IsNullOrEmpty(user.PrivateKey) || string.IsNullOrEmpty(user.PublicKey)))
{
localBox.PrivateKey = Convert.FromBase64String(user.PrivateKey);
localBox.PublicKey = Convert.FromBase64String(user.PublicKey);
}
DataLayer.Instance.AddOrUpdateLocalBox(localBox);
}
public Task <Share> GetShareSettings(string pathOfShare)
{
try{
LocalBox box = DataLayer.Instance.GetSelectedOrDefaultBox();
var explorer = new RemoteExplorer(box);
return(explorer.GetShareSettings(pathOfShare));
}
catch (Exception ex) {
Insights.Report(ex);
return(null);
}
}
private void RemoveKeys(string path, List <Identity> toRemove)
{
LocalBox box = DataLayer.Instance.GetSelectedOrDefaultBox();
var explorer = new RemoteExplorer(box);
foreach (var identity in toRemove)
{
explorer.RevokeAesKey(path, new AesKeyRevoke()
{
Username = identity.Username
});
}
}
public Task <bool> ShareFolder(string path, List <Identity> users)
{
return(Task.Run(() => {
LocalBox box = DataLayer.Instance.GetSelectedOrDefaultBox();
var explorer = new RemoteExplorer(box);
var messages = AddKeys(path, users, users.Select(e => e).ToList());
foreach (var message in messages)
{
var r = explorer.AddAesKey(path, message);
}
return explorer.ShareFolder(path, users);
}));
}
public override async void ViewDidAppear(bool didAppear)
{
ActivityIndicator.Hidden = false;
ActivityIndicator.StartAnimating();
// Perform any additional setup after loading the view, typically from a nib.
if (DataLayer.Instance.GetLocalBoxesSync().Count > 0)
{
var remoteExplorer = new RemoteExplorer();
try {
List <Site> sites = await remoteExplorer.GetSites();
foreach (LocalBox box in DataLayer.Instance.GetLocalBoxesSync())
{
for (int i = 0; i < sites.Count; i++)
{
if (box.BaseUrl == sites [i].Url)
{
sites.RemoveAt(i);
break;
}
}
}
ActivityIndicator.StopAnimating();
ActivityIndicator.Hidden = true;
_tableSource = new TableSource(sites);
TableView.Source = _tableSource;
TableView.ReloadData();
if (sites.Count == 0)
{
GeenSites.Hidden = false;
if (_introduction)
{
ToevoegenButton.SetTitle("Verder", UIControlState.Normal);
}
}
} catch (Exception ex) {
Insights.Report(ex);
DialogHelper.ShowErrorDialog("Fout", "Er is een fout opgetreden tijdens het ophalen van de sites.");
}
}
}
public Task <TreeNode> GetFolder(string path, bool refresh = false)
{
return(Task.Run(() =>
{
if (refresh)
{
RefreshFolder(path);
}
var result = database.GetTree(path);
if (result != null && result.Children.Count == 0)
{
RefreshFolder(path);
result = database.GetTree(path);
UpdateFolderKey(result);
}
else // root is null
{
if (result == null && (path.Equals("/") || path.Equals("")))
{
int boxId = Waardes.Instance.GeselecteerdeBox;
var node = new TreeNode()
{
Name = "Root",
Path = "/",
ParentId = 0,
IsDirectory = true,
LocalBoxId = boxId
};
database.AddNode(node);
//Create unencrypted public folder in empty root directory
var explorer = new RemoteExplorer();
string nameOfUser = explorer.GetUser().Name;
CreateFolder("/Publiek - " + nameOfUser, false);
RefreshFolder(node.Path);
result = database.GetTree(path);
}
}
return result;
}));
}
private List <AesKeyPost> AddKeys(string path, List <Identity> usersToShareWith, List <Identity> toAdd)
{
List <AesKeyPost> result = new List <AesKeyPost> ();
try {
LocalBox box = DataLayer.Instance.GetSelectedOrDefaultBox();
var explorer = new RemoteExplorer(box);
var node = DataLayer.Instance.GetFolder(path).Result;
if (node.HasCryptoKeys)
{
foreach (var identity in toAdd)
{
var user = explorer.GetUser(identity.Username);
if (!string.IsNullOrEmpty(user.PublicKey))
{
byte[] pkey = Convert.FromBase64String(user.PublicKey);
result.Add(new AesKeyPost()
{
User = identity.Username,
Key = Convert.ToBase64String(CryptoHelper.EncryptPgp(node.Key, pkey)),
IV = Convert.ToBase64String(CryptoHelper.EncryptPgp(node.IV, pkey))
});
}
else
{
var u = identity;
usersToShareWith.RemoveAll(e => e.Id.Equals(u.Id));
}
}
}
return(result);
}
catch (Exception ex) {
Insights.Report(ex);
return(result);
}
}
private void RefreshFolder(string path)
{
var explorer = new RemoteExplorer();
//Get all pending share inventations and accept them
List <ShareInventation> foundInventations = explorer.GetPendingShareInventations();
foreach (ShareInventation foundShareInventation in foundInventations) //Accept all inventations
{
explorer.AcceptShareInventation(foundShareInventation.Id);
}
var localData = database.GetTree(path);
var remoteData = MapDataGroupToTreeNode(explorer.GetFiles(localData.Path), localData.Id, localData.LocalBoxId);
List <string> inBoth = (from local in localData.Children
join remote in remoteData
on local.Path equals remote.Path
select local.Path).ToList();
List <TreeNode> updateNodes = (from local in localData.Children
join remote in remoteData
on local.Path equals remote.Path
select new TreeNode {
Id = local.Id, Name = remote.Name, Type = local.Type,
ParentId = local.ParentId, Path = local.Path, IsDirectory = remote.IsDirectory, HasKeys = remote.HasKeys,
IsFavorite = local.IsFavorite, IsShare = remote.IsShare, IsShared = remote.IsShared, IsWritable = remote.IsWritable, LocalBoxId = local.LocalBoxId, IV = local.IV, Key = local.Key, CheckedForKeys = local.CheckedForKeys
}).ToList();
var toAdd = remoteData.Where(e => !inBoth.Contains(e.Path)).ToList();
var toRemove = localData.Children.Where(e => !inBoth.Contains(e.Path)).ToList();
updateNodes.ForEach(e => database.Update(e));
toAdd.ForEach(e => database.AddNode(e));
toRemove.ForEach(e => {
DeleteLocalFileOrFolder(e);
database.RemoveNode(e);
});
}
private void UpdateFolderKey(TreeNode node)
{
// alleen keys ophalen als het nog niet eerder is gedaan en het op een map op het rootniveau is.
if (!node.CheckedForKeys && node.Path.Count(e => e == '/') == 1 && node.Path.Length > 1)
{
var explorer = new RemoteExplorer();
AesKeyResponse response;
if (explorer.GetAesKey(node.Path, out response))
{
if (response != null && response.IV != null && response.Key != null)
{
var encryptedIV = Convert.FromBase64String(response.IV);
var encryptedKey = Convert.FromBase64String(response.Key);
var box = GetSelectedOrDefaultBox();
node.Key = CryptoHelper.DecryptPgp(encryptedKey, box.PrivateKey, box.PassPhrase);
node.IV = CryptoHelper.DecryptPgp(encryptedIV, box.PrivateKey, box.PassPhrase);
}
node.CheckedForKeys = true;
database.Update(node);
}
}
}
public Task <bool> CreateFolder(string path, bool encrypt = true)
{
return(Task.Run(() =>
{
var explorer = new RemoteExplorer();
var result = explorer.CreateFolder(path);
// kijken of het een map op rootniveau is
if (encrypt && path.Count(e => e == '/') == 1)
{
AESKeyAndIVGenerator gen = new AESKeyAndIVGenerator();
var box = GetSelectedOrDefaultBox();
var post = new AesKeyPost()
{
User = null,
Key = Convert.ToBase64String(CryptoHelper.EncryptPgp(gen.aesKey, box.PublicKey)),
IV = Convert.ToBase64String(CryptoHelper.EncryptPgp(gen.aesIV, box.PublicKey))
};
var keyResult = explorer.AddAesKey(path, post);
}
return result;
}));
}
public string GetFilePathSync(string path)
{
var documentsPath = DocumentConstants.DocumentsPath;
var pathToFile = Path.Combine(documentsPath, "" + Waardes.Instance.GeselecteerdeBox, path.Substring(1, path.Length - 1));
EmptyDecryptedFolder();
if (!File.Exists(pathToFile)) //Does not exist
{
var explorer = new RemoteExplorer();
var fileBytes = explorer.GetFile(path);
if (fileBytes == null)
{
return(null);
}
if (!Directory.Exists(pathToFile.Substring(0, pathToFile.LastIndexOf("/"))))
{
Directory.CreateDirectory(pathToFile.Substring(0, pathToFile.LastIndexOf("/")));
}
if (pathToFile != null)
{
File.WriteAllBytes(pathToFile, fileBytes);
}
}
// moeten buiten de root zitten
if (path.Count(e => e == '/') > 1)
{
int index = path.IndexOf('/', path.IndexOf('/') + 1);
var rootFolder = path.Substring(0, index);
var folder = GetFolder(rootFolder).Result;
if (folder.HasCryptoKeys)
{
try{
Rijndael rijndael = Rijndael.Create();
rijndael.Key = folder.Key;
rijndael.IV = folder.IV;
var decpath = Path.Combine(documentsPath, "decrypted", path.Substring(1, path.Length - 1));
if (!Directory.Exists(decpath.Substring(0, decpath.LastIndexOf("/"))))
{
Directory.CreateDirectory(decpath.Substring(0, decpath.LastIndexOf("/")));
}
using (var stream = new CryptoStream(File.OpenRead(pathToFile), rijndael.CreateDecryptor(), CryptoStreamMode.Read))
using (var fs = File.OpenWrite(decpath))
{
stream.CopyTo(fs);
}
return(decpath);
}catch (Exception ex) {
Insights.Report(ex);
return(pathToFile);
}
}
}
return(pathToFile);
}
