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);
}
}
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;
}
}
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<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;
}
}
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 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;
}
});
}
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> 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> DeleteFileOrFolder(string fileOrFolderPath) {
return Task.Run (() => {
var remoteExplorer = new RemoteExplorer();
DeleteLocalFileOrFolder(fileOrFolderPath);
return remoteExplorer.DeleteFile(fileOrFolderPath);
});
}
public Task<PublicUrl> CreatePublicFileShare(string filePath, DateTime expirationDateOfShare)
{
return Task.Run (() => {
var remoteExplorer = new RemoteExplorer();
return remoteExplorer.CreatePublicFileShare(filePath, expirationDateOfShare);
});
}
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;
}
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 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<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;
});
}
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;
}
});
}
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 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;
});
}
