public FileAES_Encrypt(string file, string password = null)
{
if (!String.IsNullOrEmpty(file))
{
_fileToEncrypt = new FAES_File(file);
}
else
{
throw new ArgumentException("Parameter cannot be null", "file");
}
InitializeComponent();
versionLabel.Text = core.GetVersionInfo();
copyrightLabel.Text = core.getCopyrightInfo();
populateCompressionModes();
if (Program.doEncryptFile)
{
fileName.Text = _fileToEncrypt.getFileName();
}
else if (Program.doEncryptFolder)
{
fileName.Text = _fileToEncrypt.getFileName().TrimEnd(Path.DirectorySeparatorChar);
}
this.Focus();
this.ActiveControl = passwordInput;
_autoPassword = password;
progressBar.CustomText = "";
progressBar.VisualMode = ProgressBarDisplayMode.Percentage;
}
public void IsFolderCheck()
{
string filePath = "TestFolder";
try
{
FileAES_Utilities.SetVerboseLogging(true);
Directory.CreateDirectory(filePath);
File.WriteAllText(Path.Combine(filePath, "TestFile.txt"), "Test");
FAES_File faesFile = new FAES_File(filePath);
if (!faesFile.IsFolder())
{
Assert.Fail("FAES_File incorrectly assumes a file is a folder!");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
if (Directory.Exists(filePath))
{
Directory.Delete(filePath, true);
}
}
}
/// <summary>
/// Decompress an encrypted FAES File.
/// </summary>
/// <param name="encryptedFile">Encrypted FAES File</param>
/// <param name="overridePath">Override the read path</param>
/// <returns>Path of the encrypted, Decompressed file</returns>
public string DecompressFAESFile(FAES_File encryptedFile, string overridePath = "")
{
string fileCompressionMode = FileAES_Utilities.GetCompressionMode(encryptedFile.GetPath());
Logging.Log(String.Format("Compression Mode: {0}", fileCompressionMode), Severity.DEBUG);
switch (fileCompressionMode)
{
case "LZMA":
LZMA lzma = new LZMA();
return(lzma.DecompressFAESFile(encryptedFile, overridePath));
case "TAR":
TAR tar = new TAR();
return(tar.DecompressFAESFile(encryptedFile, overridePath));
case "ZIP":
ZIP zip = new ZIP(_compressionLevel);
return(zip.DecompressFAESFile(encryptedFile, overridePath));
case "LEGACY":
case "LEGACYZIP":
case "LGYZIP":
LegacyZIP legacyZip = new LegacyZIP();
return(legacyZip.DecompressFAESFile(encryptedFile, overridePath));
default:
throw new NotSupportedException("FAES File was compressed using an unsupported file format.");
}
}
/// <summary>
/// Decompress an encrypted FAES File.
/// </summary>
/// <param name="encryptedFile">Encrypted FAES File</param>
/// <param name="overridePath">Override the read path</param>
/// <returns>Path of the encrypted, Decompressed file</returns>
public string DecompressFAESFile(FAES_File encryptedFile, string overridePath = "")
{
string path;
if (!String.IsNullOrWhiteSpace(overridePath))
{
path = overridePath;
}
else
{
path = Path.ChangeExtension(encryptedFile.GetPath(), FileAES_Utilities.ExtentionUFAES);
}
using (Stream stream = File.OpenRead(path))
{
var reader = ReaderFactory.Open(stream);
while (reader.MoveToNextEntry())
{
reader.WriteEntryToDirectory(Directory.GetParent(Path.ChangeExtension(path, Path.GetExtension(encryptedFile.GetOriginalFileName())))?.FullName, new ExtractionOptions()
{
ExtractFullPath = true, Overwrite = true
});
}
}
return(path);
}
private void FAESMenuHandler(FAES_File faesFile)
{
if (faesFile.IsFileEncryptable())
{
Logging.Log(
$"FAES_GUI(MainGUI): FAESMenuHandler detected a valid, encryptable file! ({faesFile.GetPath()})", Severity.DEBUG);
encryptMenuButton_Click(null, null);
encryptMenuButton.Selected = true;
autoSelectMenuButton.Selected = false;
encryptPanel.SetFileToEncrypt(faesFile);
}
else if (faesFile.IsFileDecryptable())
{
Logging.Log(
$"FAES_GUI(MainGUI): FAESMenuHandler detected a valid, decryptable file! ({faesFile.GetPath()})", Severity.DEBUG);
decryptMenuButton_Click(null, null);
decryptMenuButton.Selected = true;
autoSelectMenuButton.Selected = false;
decryptPanel.SetFileToDecrypt(faesFile);
}
else
{
Logging.Log($"FAES_GUI(MainGUI): FAESMenuHandler detected an invalid file! ({faesFile.GetPath()})", Severity.DEBUG);
}
}
public void IsFileEncryptable()
{
string filePath = "TestFile.txt";
try
{
FileAES_Utilities.SetVerboseLogging(true);
File.WriteAllText(filePath, "Test");
FAES_File faesFile = new FAES_File(filePath);
if (!faesFile.IsFileEncryptable())
{
Assert.Fail("FAES_File incorrectly assumes file cannot be encrypted!");
}
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void FAESv0_MetaData()
{
string filePath = "ExampleFiles/EncryptedFiles/Legacy.mcrypt";
string expectedVer = "Pre-v1.0.0";
string actualVer = string.Empty;
try
{
FileAES_Utilities.SetVerboseLogging(true);
FAES_File faesFile = new FAES_File(filePath);
actualVer = faesFile.GetEncryptionVersion();
if (expectedVer != actualVer)
{
Assert.Fail("Incorrect encryption version!");
}
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
finally
{
Console.WriteLine("\r\n=== Test Values ===\r\n");
Console.WriteLine("Expected Ver: '{0}' | Actual Ver: '{1}'", expectedVer, actualVer);
}
}
public static bool IsFileValidForPeek(FAES_File file)
{
if (file.IsFileDecryptable())
{
return(_supportedPeekFiles.Contains(Path.GetExtension(file.GetOriginalFileName()).ToUpper()));
}
return(false);
}
public decryptPanel(FAES_File faesFile)
{
Initialise();
if (!SetFileToDecrypt(faesFile))
{
throw new Exception("Input file cannot be decrypted!");
}
}
private void selectDecryptButton_Click(object sender, EventArgs e)
{
if (Control.ModifierKeys == Keys.Shift)
{
ResetFile();
}
else if (openFileToDecrypt.ShowDialog() == DialogResult.OK)
{
FAES_File tFaesFile = new FAES_File(openFileToDecrypt.FileName);
SetFileToDecrypt(tFaesFile);
}
}
/// <summary>
/// Compress (TAR/BZip2) an unencrypted FAES File.
/// </summary>
/// <param name="unencryptedFile">Unencrypted FAES File</param>
/// <returns>Path of the unencrypted, TAR/BZip2 compressed file</returns>
public string CompressFAESFile(FAES_File unencryptedFile)
{
FileAES_IntUtilities.CreateEncryptionFilePath(unencryptedFile, "TAR", out string tempRawPath, out _, out string tempOutputPath);
TarWriterOptions wo = new TarWriterOptions(CompressionType.BZip2, true);
using (Stream stream = File.OpenWrite(tempOutputPath))
using (var writer = new TarWriter(stream, wo))
{
writer.WriteAll(tempRawPath, "*", SearchOption.AllDirectories);
}
return(tempOutputPath);
}
/// <summary>
/// Compress (LZMA) an unencrypted FAES File.
/// </summary>
/// <param name="unencryptedFile">Unencrypted FAES File</param>
/// <returns>Path of the unencrypted, LZMA compressed file</returns>
public string CompressFAESFile(FAES_File unencryptedFile)
{
FileAES_IntUtilities.CreateEncryptionFilePath(unencryptedFile, "LZMA", out string tempRawPath, out _, out string tempOutputPath);
WriterOptions wo = new WriterOptions(CompressionType.LZMA);
using (Stream stream = File.OpenWrite(tempOutputPath))
using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, wo))
{
writer.WriteAll(tempRawPath, "*", SearchOption.AllDirectories);
}
return(tempOutputPath);
}
public void FAESv3_MetaData()
{
string filePath = "ExampleFiles/EncryptedFiles/FAESv3.faes";
string expectedOriginalName = "Example.txt";
string expectedHint = "Hint";
string expectedVer = "v1.2.0-RC_1";
string actualOriginalName = string.Empty;
string actualHint = string.Empty;
string actualVer = string.Empty;
try
{
FileAES_Utilities.SetVerboseLogging(true);
FAES_File faesFile = new FAES_File(filePath);
actualOriginalName = faesFile.GetOriginalFileName();
if (expectedOriginalName != actualOriginalName)
{
Assert.Fail("Incorrect original name!");
}
actualHint = faesFile.GetPasswordHint();
if (expectedHint != actualHint)
{
Assert.Fail("Incorrect password hint!");
}
actualVer = faesFile.GetEncryptionVersion();
if (expectedVer != actualVer)
{
Assert.Fail("Incorrect encryption version!");
}
// TODO: Add more metadata checks
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
finally
{
Console.WriteLine("\r\n=== Test Values ===\r\n");
Console.WriteLine("Expected Name: '{0}' | Actual Name: '{1}'", expectedOriginalName, actualOriginalName);
Console.WriteLine("Expected Hint: '{0}' | Actual Hint: '{1}'", expectedHint, actualHint);
Console.WriteLine("Expected Ver: '{0}' | Actual Ver: '{1}'", expectedVer, actualVer);
}
}
public void File_Decrypt(string exampleFileName, string subFolder)
{
string folderName = Path.Combine("ExampleFiles", subFolder);
string originalFileContents = "ExampleString";
string finalFileContents = string.Empty;
string password = "******";
string filePath = Path.Combine(folderName, exampleFileName);
string exportPath = string.Empty;
try
{
FileAES_Utilities.SetVerboseLogging(true);
FAES_File decFile = new FAES_File(filePath);
exportPath = Path.Combine(folderName, "Example.txt");
FileAES_Decrypt decrypt = new FileAES_Decrypt(decFile, password, false);
bool decryptSuccess = decrypt.DecryptFile();
if (!decryptSuccess)
{
throw new Exception("Decryption Failed! 'decryptFile' was false.");
}
finalFileContents = File.ReadAllText(exportPath).TrimEnd('\n', '\r', ' ');
if (finalFileContents != originalFileContents)
{
throw new Exception("Final file contents does not match original!");
}
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
if (!String.IsNullOrWhiteSpace(exportPath) && File.Exists(exportPath))
{
File.Delete(exportPath);
}
Console.WriteLine("\r\n=== Test Values ===\r\n");
Console.WriteLine("filePath: {0}", filePath);
Console.WriteLine("exportPath: {0}", exportPath);
Console.WriteLine("Initial Contents: {0}", originalFileContents.Replace("\r\n", "\\r\\n"));
Console.WriteLine("Final Contents: {0}", finalFileContents.Replace("\r\n", "\\r\\n"));
}
}
public bool SetFileToEncrypt(FAES_File faesFile)
{
if (faesFile.IsFileEncryptable())
{
_fileToEncrypt = faesFile;
fileInfoLabel.Text = _fileToEncrypt.GetFileName();
Locked(false);
encryptButton.Enabled = false;
this.ActiveControl = passTextbox;
Logging.Log($"FAES_GUI(SetFileToEncrypt): '{_fileToEncrypt.GetPath()}'", Severity.DEBUG);
return(true);
}
return(false);
}
/// <summary>
/// Compress (ZIP) an unencrypted FAES File.
/// </summary>
/// <param name="unencryptedFile">Unencrypted FAES File</param>
/// <returns>Path of the unencrypted, ZIP compressed file</returns>
public string CompressFAESFile(FAES_File unencryptedFile)
{
FileAES_IntUtilities.CreateEncryptionFilePath(unencryptedFile, "ZIP", out string tempRawPath, out _, out string tempOutputPath);
ZipWriterOptions wo = new ZipWriterOptions(CompressionType.Deflate)
{
DeflateCompressionLevel = _compressLevel
};
using (Stream stream = File.OpenWrite(tempOutputPath))
using (var writer = new ZipWriter(stream, wo))
{
writer.WriteAll(tempRawPath, "*", SearchOption.AllDirectories);
}
return(tempOutputPath);
}
public PeekForm(FAES_File faesFile)
{
InitializeComponent();
titleLabel.Text += Program.GetVersion();
base.Text = titleLabel.Text;
peekPanel.LockFileSelect(true);
peekPanel.SetFileToDecrypt(faesFile);
if (!Program.programManager.GetSkipUpdates())
{
UpdateForm updateForm = new UpdateForm();
updateForm.CheckForUpdate();
}
}
/// <summary>
/// Decompress an encrypted FAES File.
/// </summary>
/// <param name="encryptedFile">Encrypted FAES File</param>
/// <param name="overridePath">Override the read path</param>
/// <returns>Path of the encrypted, Decompressed file</returns>
public string DecompressFAESFile(FAES_File encryptedFile, string overridePath = "")
{
string path;
if (!String.IsNullOrWhiteSpace(overridePath))
{
path = overridePath;
}
else
{
path = Path.ChangeExtension(encryptedFile.GetPath(), FileAES_Utilities.ExtentionUFAES);
}
ZipFile.ExtractToDirectory(path, Directory.GetParent(path)?.FullName);
return(path);
}
private void selectDecryptButton_DragDrop(object sender, DragEventArgs e)
{
string[] FileList = (string[])e.Data.GetData(DataFormats.FileDrop, false);
if (FileList.Length > 1)
{
SetNote("You may only decrypt a single file or folder at a time.", 2);
}
else
{
FAES_File tFaesFile = new FAES_File(FileList[0]);
if (!SetFileToDecrypt(tFaesFile))
{
SetNote("Chosen file cannot be decrypted!", 2);
}
}
}
public void ResetFile()
{
decryptionTimer.Stop();
progressBar.ProgressColor = Color.Lime;
progressBar.Value = progressBar.Minimum;
Locked(true);
_fileToDecrypt = null;
fileInfoLabel.Text = "No File Selected!";
progressBar.CustomText = "";
progressBar.VisualMode = CustomControls.ProgressBarDisplayMode.Percentage;
passTextbox.Text = "";
passHintTextbox.Text = "";
encryptedFileMetaData.Text = "";
Logging.Log("FAES_GUI(ResetFile): Cleared selected file.", Severity.DEBUG);
}
public EncryptForm(FAES_File faesFile)
{
InitializeComponent();
titleLabel.Text += Program.GetVersion();
base.Text = titleLabel.Text;
encryptPanel.LockFileSelect(true);
encryptPanel.setCloseAfterOperationSuccessful(true);
encryptPanel.SetFileToEncrypt(faesFile);
if (Program.programManager.GetSkipUpdates())
{
return;
}
UpdateForm updateForm = new UpdateForm();
updateForm.CheckForUpdate();
}
/// <summary>
/// Compress (LGYZIP) an unencrypted FAES File.
/// </summary>
/// <param name="unencryptedFile">Unencrypted FAES File</param>
/// <returns>Path of the unencrypted, LGYZIP compressed file</returns>
public string CompressFAESFile(FAES_File unencryptedFile)
{
FileAES_IntUtilities.CreateEncryptionFilePath(unencryptedFile, "LGYZIP", out string tempRawPath, out _, out string tempOutputPath);
if (unencryptedFile.IsFile())
{
using (ZipArchive zip = ZipFile.Open(tempOutputPath, ZipArchiveMode.Create))
{
zip.CreateEntryFromFile(unencryptedFile.GetPath(), unencryptedFile.GetFileName());
zip.Dispose();
}
}
else
{
FileAES_IntUtilities.DirectoryCopy(unencryptedFile.GetPath(), tempRawPath);
ZipFile.CreateFromDirectory(tempRawPath, tempOutputPath);
}
return(tempOutputPath);
}
public MainForm(FAES_File faesFile = null)
{
InitializeComponent();
autoDetect.BringToFront();
titleLabel.Text += Program.GetVersion();
base.Text = titleLabel.Text;
DateTime buildDate = Program.GetBuildDate();
copyrightLabel.Text = $"© - {buildDate:yyyy} | mullak99";
longVersionLabel.Text = $"FileAES {Program.GetVersion()} | Built on {buildDate:dd/MM/yyyy} at {buildDate:hh:mm:ss tt}";
if (FileAES_Utilities.GetVerboseLogging())
{
_devForm = new DevForm();
_devForm.SetCheckUpdateAction(InvokeCheckUpdate);
// Hacky solution to the RichTextBox Console.SetOut causing issues if the DevForm is not opened at least once before encryption/decryption (otherwise it hangs)
_devForm.Show();
_devForm.Hide();
}
autoSelectMenuButton.registerDetoggles(new[] { encryptMenuButton, decryptMenuButton, settingsMenuButton, aboutMenuButton });
encryptMenuButton.registerDetoggles(new[] { autoSelectMenuButton, decryptMenuButton, settingsMenuButton, aboutMenuButton });
decryptMenuButton.registerDetoggles(new[] { autoSelectMenuButton, encryptMenuButton, settingsMenuButton, aboutMenuButton });
settingsMenuButton.registerDetoggles(new[] { autoSelectMenuButton, encryptMenuButton, decryptMenuButton, aboutMenuButton });
aboutMenuButton.registerDetoggles(new[] { autoSelectMenuButton, encryptMenuButton, decryptMenuButton, settingsMenuButton });
aboutPanel.SetIsUpdateAction(() => aboutMenuButton_Click(null, null));
aboutPanel.CheckForUpdate();
if (faesFile != null)
{
encryptPanel.setCloseAfterOperationSuccessful(true);
decryptPanel.setCloseAfterOperationSuccessful(true);
FAESMenuHandler(faesFile);
}
}
public void FAESv2_MetaData()
{
string filePath = "ExampleFiles/EncryptedFiles/FAESv2.faes";
string expectedHint = "Hint";
string expectedVer = "v1.1.0 — v1.1.2";
string actualHint = string.Empty;
string actualVer = string.Empty;
try
{
FileAES_Utilities.SetVerboseLogging(true);
FAES_File faesFile = new FAES_File(filePath);
actualHint = faesFile.GetPasswordHint();
if (expectedHint != actualHint)
{
Assert.Fail("Incorrect password hint!");
}
actualVer = faesFile.GetEncryptionVersion();
if (expectedVer != actualVer)
{
Assert.Fail("Incorrect encryption version!");
}
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
finally
{
Console.WriteLine("\r\n=== Test Values ===\r\n");
Console.WriteLine("Expected Hint: '{0}' | Actual Hint: '{1}'", expectedHint, actualHint);
Console.WriteLine("Expected Ver: '{0}' | Actual Ver: '{1}'", expectedVer, actualVer);
}
}
/// <summary>
/// Compress an unencrypted FAES File.
/// </summary>
/// <param name="unencryptedFile">Unencrypted FAES File</param>
/// <returns>Path of the unencrypted, compressed file</returns>
public string CompressFAESFile(FAES_File unencryptedFile)
{
switch (_compressionMode)
{
case CompressionMode.LZMA:
LZMA lzma = new LZMA();
Logging.Log("Compression Mode: LZMA", Severity.DEBUG);
return(lzma.CompressFAESFile(unencryptedFile));
case CompressionMode.TAR:
TAR tar = new TAR();
Logging.Log("Compression Mode: TAR", Severity.DEBUG);
return(tar.CompressFAESFile(unencryptedFile));
case CompressionMode.LGYZIP:
LegacyZIP legacyZIP = new LegacyZIP();
Logging.Log("Compression Mode: LEGACYZIP", Severity.DEBUG);
return(legacyZIP.CompressFAESFile(unencryptedFile));
default:
{
ZIP zip;
Logging.Log("Compression Mode: ZIP", Severity.DEBUG);
if (_compressionLevelRaw < 0)
{
Logging.Log(String.Format("Compression Level: {0}", _compressionLevel), Severity.DEBUG);
zip = new ZIP(_compressionLevel);
}
else
{
Logging.Log(String.Format("Compression Level: {0}", _compressionLevelRaw), Severity.DEBUG);
zip = new ZIP(_compressionLevelRaw);
}
return(zip.CompressFAESFile(unencryptedFile));
}
}
}
public FileAES_Peek(string file, string password = null)
{
if (!String.IsNullOrEmpty(file))
{
_fileToPeek = new FAES_File(file);
}
else
{
throw new ArgumentException("Parameter cannot be null", "file");
}
InitializeComponent();
versionLabel.Text = core.GetVersionInfo();
copyrightLabel.Text = core.getCopyrightInfo();
if (Program.doDecrypt)
{
fileName.Text = _fileToPeek.getFileName();
}
this.Focus();
this.ActiveControl = passwordInput;
_autoPassword = password;
progressBar.CustomText = "";
progressBar.VisualMode = ProgressBarDisplayMode.Percentage;
}
public void Folder_EncryptDecrypt(bool testCompression, FAES.Packaging.CompressionMode compressionMode, FAES.Packaging.CompressionLevel compressionLevel)
{
string encFolder = "TestFolder";
string encFilePath = "TestFile.txt";
string encPath = Path.Combine(encFolder, encFilePath);
string originalFileContents = "Hello World!\r\nTest";
string finalFileContents = string.Empty;
string password = "******";
string hint = "Example Hint";
try
{
FileAES_Utilities.SetVerboseLogging(true);
Directory.CreateDirectory(encFolder);
File.WriteAllText(encPath, originalFileContents);
FAES_File encFile = new FAES_File(encPath);
FileAES_Encrypt encrypt = new FileAES_Encrypt(encFile, password, hint);
if (testCompression)
{
encrypt.SetCompressionMode(compressionMode, compressionLevel);
}
bool encryptSuccess = encrypt.encryptFile();
if (!encryptSuccess)
{
throw new Exception("Encryption Failed! 'encryptFile' was false.");
}
string decFilePath = Path.ChangeExtension(encPath, FileAES_Utilities.ExtentionFAES);
FAES_File decFile = new FAES_File(decFilePath);
FileAES_Decrypt decrypt = new FileAES_Decrypt(decFile, password);
bool decryptSuccess = decrypt.decryptFile();
if (!decryptSuccess)
{
throw new Exception("Decryption Failed! 'decryptFile' was false.");
}
finalFileContents = File.ReadAllText(encPath).TrimEnd('\n', '\r', ' ');
if (finalFileContents != originalFileContents)
{
throw new Exception("Final file contents does not match original!");
}
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
if (Directory.Exists(encFolder))
{
Directory.Delete(encFolder, true);
}
Console.WriteLine("\r\n=== Test Values ===\r\n");
Console.WriteLine("encFolder: {0}", encFolder);
Console.WriteLine("encFilePath: {0}", encFilePath);
Console.WriteLine("encPath: {0}", encPath);
Console.WriteLine("Initial Contents: {0}", originalFileContents.Replace("\r\n", "\\r\\n"));
Console.WriteLine("Final Contents: {0}", finalFileContents.Replace("\r\n", "\\r\\n"));
}
}
static void Main(string[] args)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
for (int i = 0; i < args.Length; i++)
{
string strippedArg = args[i].ToLower();
if (Directory.Exists(args[i]))
{
_directory = args[i];
}
else if (File.Exists(args[i]))
{
_directory = args[i];
}
strippedArg = strippedArg.TrimStart('-', '/', '\\');
if (strippedArg == "verbose" || strippedArg == "v")
{
_verbose = true;
FileAES_Utilities.SetVerboseLogging(_verbose);
}
else if (string.IsNullOrEmpty(_password) && (strippedArg == "password" || strippedArg == "p") && !string.IsNullOrEmpty(args[i + 1]))
{
_password = args[i + 1];
}
else if (strippedArg == "purgetemp" || strippedArg == "deletetemp")
{
_purgeTemp = true;
}
else if (strippedArg == "help")
{
_help = true;
}
else if (string.IsNullOrEmpty(_passwordHint) && (strippedArg == "hint" || strippedArg == "passwordhint" || strippedArg == "h") && !string.IsNullOrEmpty(args[i + 1]))
{
_passwordHint = args[i + 1];
}
else if (strippedArg == "gethint" || strippedArg == "getpasswordhint")
{
_getHint = true;
}
else if (strippedArg == "gettimestamp" || strippedArg == "timestamp" || strippedArg == "encryptiondate")
{
_getEncryptTimestamp = true;
}
else if (strippedArg == "getcompression" || strippedArg == "getcompressionmethod")
{
_getEncryptCompression = true;
}
else if (strippedArg == "showprogress" || strippedArg == "progress" || strippedArg == "prog")
{
if (!string.IsNullOrEmpty(args[i + 1]) && UInt16.TryParse(args[i + 1], out _progressSleep))
{
}
_showProgress = true;
}
else if (strippedArg == "faesversion" || strippedArg == "faes" || strippedArg == "faesver")
{
_getFaesVersion = true;
}
else if (strippedArg == "faescliversion" || strippedArg == "faescliver" || strippedArg == "faescli" || strippedArg == "cliver" || strippedArg == "ver" || strippedArg == "version")
{
_getVersion = true;
_getFaesVersion = true;
}
else if (string.IsNullOrEmpty(_compressionMethod) && (strippedArg == "compression" || strippedArg == "compressionmethod" || strippedArg == "c") && !string.IsNullOrEmpty(args[i + 1]))
{
_compressionMethod = args[i + 1].ToUpper();
}
else if ((strippedArg == "level" || strippedArg == "compressionlevel" || strippedArg == "l") && !string.IsNullOrEmpty(args[i + 1]))
{
Int32.TryParse(args[i + 1], out _compressionLevel);
}
else if (strippedArg == "buffer" || strippedArg == "cryptostreambuffer" || strippedArg == "csbuffer" && !string.IsNullOrEmpty(args[i + 1]))
{
UInt32.TryParse(args[i + 1], out _csBuffer);
}
else if (strippedArg == "overwrite" || strippedArg == "overwriteduplicates" || strippedArg == "o")
{
_overwriteDuplicates = true;
}
else if (strippedArg == "preserveoriginal" || strippedArg == "original" || strippedArg == "po")
{
_deleteOriginalFile = false;
}
else if (strippedArg == "showallmetadata" || strippedArg == "showmetadata" || strippedArg == "metadata")
{
_showAllMetadata = true;
}
else if (strippedArg == "showallutf8metadata" || strippedArg == "showutf8metadata" || strippedArg == "utf8metadata")
{
_showAllMetadataString = true;
}
else if (strippedArg == "" || strippedArg == "showutf8metadata" || strippedArg == "utf8metadata")
{
_showAllMetadataString = true;
}
else if (strippedArg == "tempencrypt" || strippedArg == "temp")
{
_useLocalEncrypt = false;
}
else if (strippedArg == "localencrypt" || strippedArg == "local")
{
_useLocalEncrypt = true;
}
else if (strippedArg == "showlatest" || strippedArg == "getlatest" || strippedArg == "getlatestversion" || strippedArg == "latestversion" || strippedArg == "latest")
{
_showLatestVer = true;
if (args.Length > (i + 1) && !string.IsNullOrEmpty(args[i + 1]))
{
string arg = args[i + 1];
if (arg.ToLower() == "dev" || arg.ToLower() == "developer" || arg.ToLower() == "d")
{
_showLatestBranch = "dev";
}
else if (arg.ToLower() == "beta" || arg.ToLower() == "b")
{
_showLatestBranch = "beta";
}
else if (arg.ToLower() == "stable" || arg.ToLower() == "s" || arg.ToLower() == "release" || arg.ToLower() == "r")
{
_showLatestBranch = "stable";
}
}
}
else if (strippedArg == "noupdatecheck" || strippedArg == "nocheck" || strippedArg == "offline" || strippedArg == "noupdate")
{
_checkForUpdate = false;
}
else if (strippedArg == "update" || strippedArg == "u")
{
string branch = "";
string version = "";
if (args.Length > (i + 1) && !string.IsNullOrEmpty(args[i + 1]))
{
string arg = args[i + 1];
{
BranchFinder:
switch (arg.ToLower())
{
case "dev":
case "developer":
case "d":
branch = "dev";
break;
case "beta":
case "b":
branch = "beta";
break;
case "stable":
case "s":
case "release":
case "r":
branch = "stable";
break;
default:
{
if (args.Length > (i + 2) && !string.IsNullOrEmpty(args[i + 2]) && string.IsNullOrWhiteSpace(version))
{
version = args[i + 1];
arg = args[i + 2];
goto BranchFinder;
}
break;
}
}
}
if (string.IsNullOrEmpty(branch) && string.IsNullOrEmpty(version) && args.Length > (i + 1) && !string.IsNullOrEmpty(args[i + 1]))
{
version = args[i + 1];
}
}
if (args.Length > (i + 1) && string.IsNullOrEmpty(args[i + 1]) && args[i + 1].ToLower() == "force")
{
_forceUpdate = true;
}
else if (args.Length > (i + 2) && string.IsNullOrEmpty(args[i + 2]) && args[i + 2].ToLower() == "force")
{
_forceUpdate = true;
}
else if (args.Length > (i + 3) && string.IsNullOrEmpty(args[i + 3]) && args[i + 3].ToLower() == "force")
{
_forceUpdate = true;
}
if (!string.IsNullOrWhiteSpace(branch))
{
_updateBranch = branch;
}
if (!string.IsNullOrWhiteSpace(version))
{
_updateToVer = version;
}
_doUpdate = true;
}
_strippedArgs.Add(strippedArg);
}
if (_checkForUpdate)
{
if (_updateBranch == "unknown")
{
if (IsDevBuild())
{
_updateBranch = "dev";
}
else if (IsBetaBuild())
{
_updateBranch = "beta";
}
else
{
_updateBranch = "stable";
}
}
_update = new Update("dev");
}
if (_showLatestBranch == "unknown")
{
_showLatestBranch = _updateBranch;
}
if (_help)
{
Logging.Log("A FAES-based tool for encrypting and decrypting files using the command-line.\n\nPossible Launch Parameters:\n'--verbose' or '-v': Show more debugging information in the console (WIP)." +
"\n'--purgeTemp' or '-p': Purge the FileAES Temp folder to resolve possible errors.\n'--password <password>' or '-p <password>': Sets the password that will be used to encrypt/decrypt the file/folder." +
"\n'--hint <Password Hint>' or '-h <Password Hint>': Sets a password hint.\n'--compression <ZIP/TAR/LZMA/LEGACYZIP>' or '-c <ZIP/TAR/LZMA/LEGACYZIP>': Sets the compression method that will be used to encrypt the file/folder." +
"\n'--level <0-9>' or '-l <0-9>': Sets the compression level that will be used to encrypt the file/folder. (Only works for with the ZIP compression method)" +
".\n'--getHint': Gets the password hint for the encrypted file.\n'--getTimestamp': Gets the encryption timestamp of the encrypted file." +
"\n'--getCompression': Gets the compression method of the encrypted file.\n'--ver': Gets the current version of FileAES-CLI and FAES being used." +
"\n'--FAES': Gets the current version of FAES being used.\n'--overwrite' or '-o': Overwrites any duplicate files found within the FAES process." +
"\n'--original' or '-po': Preserves the original file used in the encrypt/decrypt process." +
"\n'--progress [<Polling Rate (ms)>]': Outputs the current encryption/decryption progress to the console after desired time (Leaving polling rate blank defaults to 5000ms)." +
"\n'--buffer <Size (bytes)>': Sets the size of the FAES CryptoStream buffer.\n'--metadata': Shows the raw metadeta (Hex) of the encrypted file." +
"\n'--utf8metadata': Shows the raw metadeta (Decoded UTF8) of the encrypted file.\n'--offline': Disables auto-update checking." +
"\n'--latest [<branch>]': Outputs the latest version of FileAES-CLI on that branch (Leaving branch blank defaults to current builds branch)." +
"\n'--update [<version>] [<branch>] [force]': Updates FileAES-CLI as specified. Using no arguments updates to the latest version on the current branch.\n\n" +
"\n'--localEncrypt' or '-local': Encrypt files within the same folder as the source file (Default behaviour).\n\n" +
"\n'--tempEncrypt' or '-temp': Encrypt files within the OS' Temp folder (Old behaviour).\n\n" +
"File/Folder names can be entered as a launch parameter to select what to encrypt/decrypt (also allows for dragging/dropping a file/folder on the .exe).\n\n" +
"Example: 'FileAES-CLI.exe File.txt -p password123'");
return;
}
if (_doUpdate)
{
if (_update != null && _checkForUpdate)
{
_update.CheckForUpdateNonThreadded(true);
bool doUpdate = false;
if ((!_forceUpdate && _update.IsUpdate()) || _forceUpdate || _updateToVer != "latest")
{
if (_updateToVer == "latest")
{
string latestVer = _update.GetLatestVersion();
Logging.Log($"Installing FileAES-CLI {latestVer}...");
doUpdate = true;
}
else if (_update.DoesVersionExist(_updateToVer, "dev"))
{
Logging.Log($"Installing FileAES-CLI {_updateToVer}...");
doUpdate = true;
}
else
{
Logging.Log($"Could not find FileAES-CLI {_updateToVer}!", Severity.WARN);
}
if (doUpdate)
{
_update.UpdateSelf(true, _updateToVer);
return;
}
}
}
}
else if (_checkForUpdate)
{
_update.CheckForUpdate();
}
if (_purgeTemp)
{
FileAES_Utilities.PurgeTempFolder();
}
if (_getVersion)
{
Logging.Log($"Current FileAES-CLI Version: {GetVersion()}");
if (!_getFaesVersion)
{
return;
}
}
if (_getFaesVersion)
{
Logging.Log($"Current FAES Version: {FileAES_Utilities.GetVersion()}");
return;
}
if (_showLatestVer)
{
if (_checkForUpdate)
{
_update.SetBranch(_showLatestBranch);
string latestVer = _update.GetLatestVersion();
if (latestVer != "v0.0.0")
{
Logging.Log(
$"The latest FileAES-CLI version on branch '{_showLatestBranch.ToUpper()}' is: {latestVer}");
}
else
{
Logging.Log("The latest FileAES-CLI version could not be found! Please check your internet connection.", Severity.WARN);
}
_update.SetBranch(_updateBranch);
}
else
{
Logging.Log("The latest version cannot be displayed when the program is in offline mode!");
}
return;
}
if (_getHint)
{
if (File.Exists(_directory) && FileAES_Utilities.IsFileDecryptable(_directory))
{
string passHint = FileAES_Utilities.GetPasswordHint(_directory);
if (passHint != "No Password Hint Set")
{
Logging.Log($"The hint for '{Path.GetFileName(_directory)}' is: {passHint}");
}
else
{
Logging.Log($"'{Path.GetFileName(_directory)}' does not contain a password hint!");
}
if (string.IsNullOrEmpty(_password) && (!_getEncryptTimestamp || !_getEncryptCompression))
{
return;
}
}
else
{
Logging.Log("You have not specified a valid encrypted file!", Severity.WARN);
return;
}
}
if (_getEncryptTimestamp)
{
if (File.Exists(_directory) && FileAES_Utilities.IsFileDecryptable(_directory))
{
long timestamp = FileAES_Utilities.GetEncryptionTimeStamp(_directory);
if (timestamp >= 0)
{
DateTime dateTime = FileAES_Utilities.UnixTimeStampToDateTime((double)timestamp);
Logging.Log(
$"'{Path.GetFileName(_directory)}' was encrypted on {dateTime.ToString("dd/MM/yyyy")} at {dateTime.ToString("HH:mm:ss tt")}.");
}
else
{
Logging.Log("This file does not contain a encryption date. This is likely due to this file being encrypted using an older FAES version.");
}
if (string.IsNullOrEmpty(_password) && !_getEncryptCompression)
{
return;
}
}
else
{
Logging.Log("You have not specified a valid encrypted file!", Severity.WARN);
return;
}
}
if (_getEncryptCompression)
{
if (File.Exists(_directory) && FileAES_Utilities.IsFileDecryptable(_directory))
{
string compressionMode = FileAES_Utilities.GetCompressionMode(_directory);
if (compressionMode != "LGYZIP")
{
Logging.Log(
$"The Compression Mode used for '{Path.GetFileName(_directory)}' is: {compressionMode}");
}
else
{
Logging.Log(
$"The Compression Mode used for '{Path.GetFileName(_directory)}' is: LGYZIP (LEGACYZIP)");
}
if (string.IsNullOrEmpty(_password))
{
return;
}
}
else
{
Logging.Log("You have not specified a valid encrypted file!", Severity.WARN);
return;
}
}
if (_showAllMetadata)
{
if (File.Exists(_directory) && FileAES_Utilities.IsFileDecryptable(_directory))
{
string compressionMode = FileAES_Utilities.GetCompressionMode(_directory);
MetaData faesMetaData = new MetaData(_directory);
if (faesMetaData.IsLegacyVersion())
{
Logging.Log(
$"The metadata (bytes) for '{Path.GetFileName(_directory)}' is (FAESv2):\n{BitConverter.ToString(faesMetaData.GetMetaData())}");
}
else
{
Logging.Log(
$"The metadata (bytes) for '{Path.GetFileName(_directory)}' is (FAESv3):\n{BitConverter.ToString(faesMetaData.GetMetaData())}");
}
if (string.IsNullOrEmpty(_password))
{
return;
}
}
else
{
Logging.Log("You have not specified a valid encrypted file!", Severity.WARN);
return;
}
}
if (_showAllMetadataString)
{
if (File.Exists(_directory) && FileAES_Utilities.IsFileDecryptable(_directory))
{
string compressionMode = FileAES_Utilities.GetCompressionMode(_directory);
MetaData faesMetaData = new MetaData(_directory);
if (faesMetaData.IsLegacyVersion())
{
Logging.Log(
$"The metadata (string) for '{Path.GetFileName(_directory)}' is (FAESv2):\n{Encoding.UTF8.GetString(faesMetaData.GetMetaData())}");
}
else
{
Logging.Log(
$"The metadata (string) for '{Path.GetFileName(_directory)}' is (FAESv3):\n{Encoding.UTF8.GetString(faesMetaData.GetMetaData())}");
}
if (string.IsNullOrEmpty(_password))
{
return;
}
}
else
{
Logging.Log("You have not specified a valid encrypted file!", Severity.WARN);
return;
}
}
if (string.IsNullOrEmpty(_directory))
{
while (true)
{
Console.Write("File/Folder: ");
_directory = Console.ReadLine();
if (File.Exists(_directory) || Directory.Exists(_directory))
{
break;
}
Logging.Log("You have not specified a valid file or folder!", Severity.WARN);
}
}
if (string.IsNullOrEmpty(_password))
{
while (true)
{
Console.Write("Password: "******"\nConf. Password: "******"Passwords do not match!");
}
else
{
Console.Write(Environment.NewLine);
_password = password;
break;
}
}
}
if (!File.Exists(_directory) && !Directory.Exists(_directory))
{
Logging.Log("You have not specified a valid file or folder!", Severity.WARN);
}
else if (string.IsNullOrEmpty(_password))
{
Logging.Log("Please specify a password!", Severity.WARN);
}
else
{
FAES_File faesFile = new FAES_File(_directory);
FileAES_Utilities.SetCryptoStreamBuffer(_csBuffer);
try
{
if (_compressionLevel < 0 || _compressionLevel > 9)
{
Logging.Log("You have not specified a valid compression level! Please choose a value between 0 and 9.", Severity.WARN);
return;
}
else
{
if (_verbose)
{
Logging.Log(
$"CryptoStream Buffer Size: {FileAES_Utilities.GetCryptoStreamBuffer()} bytes", Severity.DEBUG);
}
if (faesFile.IsFileEncryptable())
{
FileAES_Utilities.LocalEncrypt = _useLocalEncrypt;
FileAES_Encrypt encrypt = new FileAES_Encrypt(faesFile, _password, _passwordHint, Optimise.Balanced, null, _deleteOriginalFile, _overwriteDuplicates);
if (!string.IsNullOrEmpty(_compressionMethod))
{
switch (_compressionMethod)
{
case "ZIP":
encrypt.SetCompressionMode(CompressionMode.ZIP, _compressionLevel);
break;
case "TAR":
encrypt.SetCompressionMode(CompressionMode.TAR, _compressionLevel);
break;
case "LZMA":
encrypt.SetCompressionMode(CompressionMode.LZMA, _compressionLevel);
break;
case "GZIP":
encrypt.SetCompressionMode(CompressionMode.GZIP, _compressionLevel);
break;
case "LGYZIP":
case "LEGACYZIP":
case "LEGACY":
encrypt.SetCompressionMode(CompressionMode.LGYZIP, _compressionLevel);
break;
default:
Console.WriteLine("Unknown Compression Method: {0}", _compressionMethod);
return;
}
}
Thread progressThread = new Thread(() =>
{
while (_showProgress)
{
ushort percentComplete = Convert.ToUInt16(encrypt.GetEncryptionPercentComplete());
Logging.Log($"Progress: {percentComplete}%");
Thread.Sleep(_progressSleep);
}
});
Thread eThread = new Thread(() =>
{
try
{
if (encrypt.EncryptFile())
{
if (_showProgress)
{
Logging.Log("Progress: 100%");
}
Logging.Log($"Encryption on {faesFile.getFaesType().ToLower()} succeeded!");
}
else
{
Logging.Log($"Encryption on {faesFile.getFaesType().ToLower()} failed!");
}
}
catch (Exception e)
{
#if NETFRAMEWORK
progressThread.Abort();
#endif
HandleException(e);
}
});
if (_showProgress)
{
progressThread.Start();
}
eThread.Start();
while (eThread.ThreadState == ThreadState.Running)
{
}
#if NETFRAMEWORK
progressThread.Abort();
#endif
}
else
{
FileAES_Decrypt decrypt = new FileAES_Decrypt(faesFile, _password, _deleteOriginalFile, _overwriteDuplicates);
Thread progressThread = new Thread(() =>
{
while (_showProgress)
{
ushort percentComplete = Convert.ToUInt16(decrypt.GetDecryptionPercentComplete());
Logging.Log($"Progress: {percentComplete}%");
Thread.Sleep(_progressSleep);
}
});
Thread dThread = new Thread(() =>
{
try
{
if (decrypt.DecryptFile())
{
if (_showProgress)
{
Logging.Log("Progress: 100%");
}
Logging.Log($"Decryption on {faesFile.getFaesType().ToLower()} succeeded!");
}
else
{
Logging.Log($"Decryption on {faesFile.getFaesType().ToLower()} failed!");
Logging.Log("Ensure that you entered the correct password!");
Logging.Log($"Password Hint: {faesFile.GetPasswordHint()}");
}
}
catch (Exception e)
{
#if NETFRAMEWORK
progressThread.Abort();
#endif
HandleException(e);
}
});
if (_showProgress)
{
progressThread.Start();
}
dThread.Start();
while (dThread.ThreadState == ThreadState.Running)
{
}
#if NETFRAMEWORK
progressThread.Abort();
#endif
}
}
}
catch (Exception e)
{
HandleException(e);
}
}
}
static void Main(string[] args)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
for (int i = 0; i < args.Length; i++)
{
string strippedArg = args[i].ToLower();
if (Directory.Exists(args[i]))
{
_directory = args[i];
}
else if (File.Exists(args[i]))
{
_directory = args[i];
}
strippedArg = strippedArg.TrimStart('-', '/', '\\');
if (strippedArg == "verbose" || strippedArg == "v" || strippedArg == "developer" || strippedArg == "dev" || strippedArg == "debug")
{
_verbose = true;
}
else if (strippedArg == "password" || strippedArg == "p" && !string.IsNullOrEmpty(args[i + 1]))
{
_password = args[i + 1];
}
else if (string.IsNullOrEmpty(_passwordHint) && (strippedArg == "hint" || strippedArg == "passwordhint" || strippedArg == "h") && !string.IsNullOrEmpty(args[i + 1]))
{
_passwordHint = args[i + 1];
}
else if (strippedArg == "purgetemp" || strippedArg == "deletetemp")
{
_purgeTemp = true;
}
else if (strippedArg == "headless" || strippedArg == "cli" || strippedArg == "commandline")
{
_headless = true;
}
else if (strippedArg == "showprogress" || strippedArg == "progress" || strippedArg == "prog")
{
if (!string.IsNullOrEmpty(args[i + 1]) && UInt16.TryParse(args[i + 1], out _progressSleep))
{
}
_showProgress = true;
}
else if (strippedArg == "faesversion" || strippedArg == "faes" || strippedArg == "faesver")
{
_getFaesVersion = true;
}
else if (strippedArg == "faesguiversion" || strippedArg == "faesguiver" || strippedArg == "faesgui" || strippedArg == "guiver" || strippedArg == "ver")
{
_getVersion = true;
_getFaesVersion = true;
}
else if (string.IsNullOrEmpty(_compressionMethod) && (strippedArg == "compression" || strippedArg == "compressionmethod" || strippedArg == "c") && !string.IsNullOrEmpty(args[i + 1]))
{
_compressionMethod = args[i + 1].ToUpper();
}
else if ((strippedArg == "level" || strippedArg == "compressionlevel" || strippedArg == "l") && !string.IsNullOrEmpty(args[i + 1]))
{
Int32.TryParse(args[i + 1], out _compressionLevel);
}
else if (strippedArg == "overwrite" || strippedArg == "overwriteduplicates" || strippedArg == "o")
{
_overwriteDuplicates = true;
}
else if (strippedArg == "preserveoriginal" || strippedArg == "original" || strippedArg == "po")
{
_deleteOriginalFile = false;
}
else if (strippedArg == "genfullinstallconfig")
{
_genFullInstallConfig = true;
}
else if (strippedArg == "associatefiletypes" || strippedArg == "filetypes")
{
_associateFileTypes = true;
}
else if (strippedArg == "startmenushortcuts" || strippedArg == "startmenu")
{
_startMenuShortcuts = true;
}
else if (strippedArg == "contextmenus" || strippedArg == "context")
{
_contextMenus = true;
}
else if (strippedArg == "installbranch" && !string.IsNullOrEmpty(args[i + 1]))
{
_installBranch = args[i + 1];
}
else if (strippedArg == "peek" || strippedArg == "filepeek")
{
_doFilePeek = true;
}
_strippedArgs.Add(strippedArg);
}
FileAES_Utilities.SetVerboseLogging(_verbose);
SSM.SetVerboseLogging(_verbose);
try
{
if (File.Exists("FAES-Updater.exe"))
{
File.Delete("FAES-Updater.exe");
}
}
catch
{
// ignored
}
if (_purgeTemp)
{
FileAES_Utilities.PurgeTempFolder();
}
if (_getVersion)
{
Console.WriteLine("Current FileAES Version: {0}", GetVersion());
Console.WriteLine("Current FileAES Build Date: {0}", GetBuildDateFormatted());
}
if (_getFaesVersion)
{
Console.WriteLine("Current FAES Version: {0}", FileAES_Utilities.GetVersion());
}
if (!string.IsNullOrEmpty(_directory) && !string.IsNullOrEmpty(_password) && _headless)
{
faesFile = new FAES_File(_directory);
Console.WriteLine("FileAES-GUI (FileAES) only has basic command-line support. Use FileAES-CLI for improved command-line functionality.");
try
{
if (_compressionLevel < 0 || _compressionLevel > 9)
{
Console.WriteLine("You have not specified a valid compression level! Please choose a value between 0 and 9.");
}
else
{
if (faesFile.IsFileEncryptable())
{
FileAES_Encrypt encrypt = new FileAES_Encrypt(faesFile, _password, _passwordHint, Optimise.Balanced, null, _deleteOriginalFile, _overwriteDuplicates);
if (!string.IsNullOrEmpty(_compressionMethod))
{
switch (_compressionMethod)
{
case "ZIP":
encrypt.SetCompressionMode(CompressionMode.ZIP, _compressionLevel);
break;
case "TAR":
encrypt.SetCompressionMode(CompressionMode.TAR, _compressionLevel);
break;
case "LZMA":
encrypt.SetCompressionMode(CompressionMode.LZMA, _compressionLevel);
break;
case "GZIP":
encrypt.SetCompressionMode(CompressionMode.GZIP, _compressionLevel);
break;
case "LGYZIP":
case "LEGACYZIP":
case "LEGACY":
encrypt.SetCompressionMode(CompressionMode.LGYZIP, _compressionLevel);
break;
default:
Console.WriteLine("Unknown Compression Method: {0}", _compressionMethod);
return;
}
}
Thread progressThread = new Thread(() =>
{
while (_showProgress)
{
ushort percentComplete = Convert.ToUInt16(encrypt.GetEncryptionPercentComplete());
Console.WriteLine(_verbose ? "[INFO] Progress: {0}%" : "Progress: {0}%", percentComplete);
Thread.Sleep(_progressSleep);
}
});
Thread eThread = new Thread(() =>
{
try
{
if (encrypt.EncryptFile())
{
if (_showProgress)
{
Console.WriteLine(_verbose ? "[INFO] Progress: 100%" : "Progress: 100%");
}
Console.WriteLine("Encryption on {0} succeeded!", faesFile.getFaesType().ToLower());
}
else
{
Console.WriteLine("Encryption on {0} failed!", faesFile.getFaesType().ToLower());
}
}
catch (Exception e)
{
progressThread.Abort();
HandleException(e);
}
});
if (_showProgress)
{
progressThread.Start();
}
eThread.Start();
while (eThread.ThreadState == ThreadState.Running)
{
}
progressThread.Abort();
}
else
{
FileAES_Decrypt decrypt = new FileAES_Decrypt(faesFile, _password, _deleteOriginalFile, _overwriteDuplicates);
Thread progressThread = new Thread(() =>
{
while (_showProgress)
{
ushort percentComplete = Convert.ToUInt16(decrypt.GetDecryptionPercentComplete());
Console.WriteLine(_verbose ? "[INFO] Progress: {0}%" : "Progress: {0}%", percentComplete);
Thread.Sleep(_progressSleep);
}
});
Thread dThread = new Thread(() =>
{
try
{
if (decrypt.DecryptFile())
{
if (_showProgress)
{
Console.WriteLine(_verbose ? "[INFO] Progress: 100%" : "Progress: 100%");
}
Console.WriteLine("Decryption on {0} succeeded!", faesFile.getFaesType().ToLower());
}
else
{
Console.WriteLine("Decryption on {0} failed!", faesFile.getFaesType().ToLower());
Console.WriteLine("Ensure that you entered the correct password!");
Console.WriteLine("Password Hint: {0}", faesFile.GetPasswordHint());
}
}
catch (Exception e)
{
progressThread.Abort();
HandleException(e);
}
});
if (_showProgress)
{
progressThread.Start();
}
dThread.Start();
while (dThread.ThreadState == ThreadState.Running)
{
}
progressThread.Abort();
}
}
}
catch (Exception e)
{
HandleException(e);
}
}
else if (_genFullInstallConfig)
{
programManager = new ProgramManager(ProgramManager.InstallType.FullInstall);
programManager.SetBranch(_installBranch);
programManager.SetAssociateFileTypes(_associateFileTypes);
programManager.SetStartMenuShortcuts(_startMenuShortcuts);
programManager.SetContextMenus(_contextMenus);
Application.Exit();
}
else
{
programManager = new ProgramManager();
if (!FileAES_Utilities.GetVerboseLogging())
{
FileAES_Utilities.SetVerboseLogging(programManager.GetDevMode());
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
if (!string.IsNullOrEmpty(_directory))
{
faesFile = new FAES_File(_directory);
if (faesFile.IsFileEncryptable())
{
Application.Run(new EncryptForm(faesFile));
}
else if (faesFile.IsFileDecryptable())
{
if (_doFilePeek && IsFileValidForPeek(faesFile))
{
Application.Run(new PeekForm(faesFile));
}
else
{
Application.Run(new DecryptForm(faesFile));
}
}
}
else
{
Application.Run(new MainForm());
}
}
}
public MetaData(FAES_File faesFile)
{
LoadMetaDataFromFile(faesFile.GetPath());
}
