private async Task EncodeFolder(IEnumerable <string> plainfolder, string rootpath = null)
{
foreach (var folder in plainfolder)
{
if (!Directory.Exists(folder))
{
Log("folder not found : {0}", folder);
continue;
}
var encparent = rootpath;
if (encparent == null)
{
encparent = Directory.GetParent(folder).FullName;
}
string encfolder = null;
if (radioButton_NameEncryption.Checked)
{
var plainfoldername = (folder.EndsWith("\\")) ? Path.GetDirectoryName(folder) : folder;
var i = plainfoldername.LastIndexOf('\\');
if (i >= 0)
{
plainfoldername = plainfoldername.Substring(i + 1);
}
var encfoldername = CryptRclone.EncryptName(plainfoldername);
encfolder = Path.Combine(encparent, encfoldername);
if (Directory.Exists(encfolder))
{
Log("Exists : {0}", encfolder);
continue;
}
try
{
Directory.CreateDirectory(encfolder);
}
catch (Exception ex)
{
Log("CreateDirectory failed : {0} {1}", encfolder, ex.Message);
continue;
}
Log("OK : {0}->{1}", folder, encfolder);
}
else
{
encfolder = folder;
}
// subitems
var subfiles = Directory.GetFiles(folder);
var subdirs = Directory.GetDirectories(folder);
await EncodeFile(subfiles, encfolder);
await EncodeFolder(subdirs, encfolder);
}
}
private async Task DecodeFile(IEnumerable <string> encfiles, string rootpath = null)
{
foreach (var file in encfiles)
{
if (!File.Exists(file))
{
Log("file not found : {0}", file);
continue;
}
var decfilepath = rootpath;
if (decfilepath == null)
{
decfilepath = Path.GetDirectoryName(file);
}
var encfilename = Path.GetFileName(file);
string decfilename = null;
if (encfilename.EndsWith(CryptRclone.encryptedSuffix))
{
decfilename = Path.GetFileNameWithoutExtension(encfilename);
}
else
{
if (CryptRclone.IsNameEncrypted(encfilename))
{
decfilename = CryptRclone.DecryptName(encfilename);
}
if (string.IsNullOrEmpty(decfilename))
{
Log("filename decode error : {0}", file);
continue;
}
}
var decfile = Path.Combine(decfilepath, decfilename);
if (File.Exists(decfile))
{
Log("Exists : {0}", decfile);
continue;
}
try
{
using (var efile = File.OpenRead(file))
using (var dfile = File.OpenWrite(decfile))
using (var cfile = new CryptRclone.CryptRclone_DeryptStream(efile))
{
await cfile.CopyToAsync(dfile, 81920, cts.Token);
}
}
catch (Exception ex)
{
Log("Decode Error : {0}->{1} {2}", file, decfile, ex.Message);
continue;
}
Log("OK : {0}->{1}", file, decfile);
}
}
private async Task DecodeFolder(IEnumerable <string> encfolder, string rootpath = null)
{
foreach (var folder in encfolder)
{
if (!Directory.Exists(folder))
{
Log("folder not found : {0}", folder);
continue;
}
var decparent = rootpath;
if (decparent == null)
{
decparent = Directory.GetParent(folder).FullName;
}
var encfoldername = (folder.EndsWith("\\")) ? Path.GetDirectoryName(folder) : folder;
var i = encfoldername.LastIndexOf('\\');
if (i >= 0)
{
encfoldername = encfoldername.Substring(i + 1);
}
string decfoldername = null;
if (CryptRclone.IsNameEncrypted(encfoldername))
{
decfoldername = CryptRclone.DecryptName(encfoldername);
}
string decfolder = Path.Combine(decparent, encfoldername);
if (!string.IsNullOrEmpty(decfoldername))
{
decfolder = Path.Combine(decparent, decfoldername);
if (Directory.Exists(decfolder))
{
Log("Exists : {0}", decfolder);
continue;
}
try
{
Directory.CreateDirectory(decfolder);
}
catch (Exception ex)
{
Log("CreateDirectory failed : {0} {1}", decfolder, ex.Message);
continue;
}
Log("OK : {0}->{1}", folder, decfolder);
}
// subitems
var subfiles = Directory.GetFiles(folder);
var subdirs = Directory.GetDirectories(folder);
await DecodeFile(subfiles, decfolder);
await DecodeFolder(subdirs, decfolder);
}
}
private async void Form1_DragDrop(object sender, DragEventArgs e)
{
string[] fileNames = (string[])e.Data.GetData(DataFormats.FileDrop, false);
var decodes = fileNames.Where(item => CryptRclone.IsNameEncrypted(Path.GetFileName(item)));
var encodes = fileNames.Except(decodes);
await DecodeFile(decodes.Where(item => File.Exists(item)));
await DecodeFolder(decodes.Where(item => Directory.Exists(item)));
await EncodeFile(encodes.Where(item => File.Exists(item)));
await EncodeFolder(encodes.Where(item => Directory.Exists(item)));
Log("Done.");
}
public RcloneCryptSystemItem(IRemoteServer server, IRemoteItem orgItem, params IRemoteItem[] parent) : base(server, parent)
{
if (!(parent?.Length > 0))
{
isRoot = true;
}
orgpath = orgItem.FullPath;
itemtype = orgItem.ItemType;
size = ((orgItem.Size == null) ? orgItem.Size : CryptRclone.CalcDecryptedSize(orgItem.Size.Value));
modifiedDate = orgItem.ModifiedDate;
createdDate = orgItem.CreatedDate;
accessDate = orgItem.AccessDate;
var encryptor = (_server as RcloneCryptSystem).Encrypter;
if (encryptor.IsEncryptedName)
{
decryptedName = encryptor.DecryptName(orgItem.Name) ?? "";
if (decryptedName == "" && !isRoot)
{
throw new FileNotFoundException("filename dedoce error");
}
}
else
{
if (itemtype == RemoteItemType.Folder)
{
decryptedName = orgItem.Name;
}
else
{
if (orgItem.Name.EndsWith(CryptRclone.encryptedSuffix))
{
decryptedName = orgItem.Name.Substring(0, orgItem.Name.Length - CryptRclone.encryptedSuffix.Length);
}
else
{
throw new FileNotFoundException("filename dedoce error");
}
}
}
decryptedPath = OrgPathToPath(orgItem as RemoteItemBase);
if (isRoot)
{
SetParent(this);
}
}
public async override Task <bool> Add()
{
var picker = new TSviewCloud.FormTreeSelect
{
Text = "Select encrypt root folder"
};
if (picker.ShowDialog() != DialogResult.OK)
{
return(false);
}
if (picker.SelectedItem == null)
{
return(false);
}
if (picker.SelectedItem.ItemType == RemoteItemType.File)
{
return(false);
}
var pass = new FormInputPass();
if (pass.ShowDialog() != DialogResult.OK)
{
return(false);
}
Encrypter = new CryptRclone(pass.Password, pass.Salt)
{
IsEncryptedName = pass.FilenameEncryption,
};
DrivePassword = pass.Password;
DriveSalt = pass.Salt;
FilenameEncryption = pass.FilenameEncryption;
cryptRootPath = picker.SelectedItem.FullPath;
_dependService = picker.SelectedItem.Server;
var root = new RcloneCryptSystemItem(this, picker.SelectedItem, null);
pathlist.AddOrUpdate("", (k) => root, (k, v) => root);
await EnsureItem("", 1).ConfigureAwait(false);
_IsReady = true;
TSviewCloudConfig.Config.Log.LogOut("[Add] RcloneCryptSystem {0} as {1}", cryptRootPath, Name);
return(true);
}
private async Task EncodeFile(IEnumerable <string> plainfiles, string rootpath = null)
{
foreach (var file in plainfiles)
{
if (!File.Exists(file))
{
Log("file not found : {0}", file);
continue;
}
var encfilepath = rootpath;
if (encfilepath == null)
{
encfilepath = Path.GetDirectoryName(file);
}
var plainfilename = Path.GetFileName(file);
var encfilename = (radioButton_NamePlain.Checked)? plainfilename + CryptRclone.encryptedSuffix: CryptRclone.EncryptName(plainfilename);
var encfile = Path.Combine(encfilepath, encfilename);
if (File.Exists(encfile))
{
Log("Exists : {0}", encfile);
continue;
}
using (var pfile = File.OpenRead(file))
using (var efile = File.OpenWrite(encfile))
using (var cfile = new CryptRclone.CryptRclone_CryptStream(pfile))
{
try
{
await cfile.CopyToAsync(efile, 81920, cts.Token);
}
catch (Exception ex)
{
Log("Encode Error : {0}->{1} {2}", file, encfile, ex.Message);
continue;
}
}
Log("OK : {0}->{1}", file, encfile);
}
}
public void OnDeserialized(StreamingContext c)
{
TSviewCloudConfig.Config.Log.LogOut("[Restore] RcloneCryptSystem {0} as {1}", cryptRootPath, Name);
Encrypter = new CryptRclone(DrivePassword, DriveSalt)
{
IsEncryptedName = FilenameEncryption,
};
loadinglist = new ConcurrentDictionary <string, ManualResetEventSlim>();
var job = JobControler.CreateNewJob();
job.DisplayName = "CryptRclone";
job.ProgressStr = "waiting parent";
JobControler.Run(job, async(j) =>
{
j.ProgressStr = "Loading...";
j.Progress = -1;
try
{
int waitcount = 500;
while (!(RemoteServerFactory.ServerList.Keys.Contains(_dependService) && RemoteServerFactory.ServerList[_dependService].IsReady))
{
if (RemoteServerFactory.ServerList.Keys.Contains(_dependService))
{
await Task.Delay(1, j.Ct).ConfigureAwait(false);
}
else
{
await Task.Delay(1000, j.Ct).ConfigureAwait(false);
}
if (waitcount-- == 0)
{
throw new FileNotFoundException("Depend Service is not ready.", _dependService);
}
}
}
catch
{
RemoteServerFactory.Delete(this);
return;
}
if (pathlist == null)
{
pathlist = new ConcurrentDictionary <string, RcloneCryptSystemItem>();
var root = new RcloneCryptSystemItem(this, await RemoteServerFactory.PathToItem(cryptRootPath).ConfigureAwait(false), null);
pathlist.AddOrUpdate("", (k) => root, (k, v) => root);
await EnsureItem("", 1).ConfigureAwait(false);
}
else
{
Parallel.ForEach(pathlist.Values.ToArray(),
new ParallelOptions {
MaxDegreeOfParallelism = Convert.ToInt32(Math.Ceiling((Environment.ProcessorCount * 0.75) * 1.0))
},
(x) => x.FixChain(this));
}
j.ProgressStr = "Done";
j.Progress = 1;
_IsReady = true;
});
}
